Initial import with skill sheet working

node_modules/comment-parser/es6/parser/tokenizers/description.d.ts

@@ -0,0 +1,20 @@
+import { Line, BlockMarkers, Markers } from '../../primitives.js';
+import { Tokenizer } from './index.js';
+/**
+ * Walks over provided lines joining description token into a single string.
+ * */
+export type Joiner = (lines: Line[], markers?: BlockMarkers) => string;
+/**
+ * Shortcut for standard Joiners
+ * compact - strip surrounding whitespace and concat lines using a single string
+ * preserve - preserves original whitespace and line breaks as is
+ */
+export type Spacing = 'compact' | 'preserve' | Joiner;
+/**
+ * Makes no changes to `spec.lines[].tokens` but joins them into `spec.description`
+ * following given spacing srtategy
+ * @param {Spacing} spacing tells how to handle the whitespace
+ * @param {BlockMarkers} markers tells how to handle comment block delimitation
+ */
+export default function descriptionTokenizer(spacing?: Spacing, markers?: typeof Markers): Tokenizer;
+export declare function getJoiner(spacing: Spacing): Joiner;

node_modules/comment-parser/es6/parser/tokenizers/description.js

@@ -0,0 +1,47 @@
+import { Markers } from '../../primitives.js';
+/**
+ * Makes no changes to `spec.lines[].tokens` but joins them into `spec.description`
+ * following given spacing srtategy
+ * @param {Spacing} spacing tells how to handle the whitespace
+ * @param {BlockMarkers} markers tells how to handle comment block delimitation
+ */
+export default function descriptionTokenizer(spacing = 'compact', markers = Markers) {
+    const join = getJoiner(spacing);
+    return (spec) => {
+        spec.description = join(spec.source, markers);
+        return spec;
+    };
+}
+export function getJoiner(spacing) {
+    if (spacing === 'compact')
+        return compactJoiner;
+    if (spacing === 'preserve')
+        return preserveJoiner;
+    return spacing;
+}
+function compactJoiner(lines, markers = Markers) {
+    return lines
+        .map(({ tokens: { description } }) => description.trim())
+        .filter((description) => description !== '')
+        .join(' ');
+}
+const lineNo = (num, { tokens }, i) => tokens.type === '' ? num : i;
+const getDescription = ({ tokens }) => (tokens.delimiter === '' ? tokens.start : tokens.postDelimiter.slice(1)) +
+    tokens.description;
+function preserveJoiner(lines, markers = Markers) {
+    if (lines.length === 0)
+        return '';
+    // skip the opening line with no description
+    if (lines[0].tokens.description === '' &&
+        lines[0].tokens.delimiter === markers.start)
+        lines = lines.slice(1);
+    // skip the closing line with no description
+    const lastLine = lines[lines.length - 1];
+    if (lastLine !== undefined &&
+        lastLine.tokens.description === '' &&
+        lastLine.tokens.end.endsWith(markers.end))
+        lines = lines.slice(0, -1);
+    // description starts at the last line of type definition
+    lines = lines.slice(lines.reduce(lineNo, 0));
+    return lines.map(getDescription).join('\n');
+}

node_modules/comment-parser/es6/parser/tokenizers/index.d.ts

@@ -0,0 +1,7 @@
+import { Spec } from '../../primitives.js';
+/**
+ * Splits `spect.lines[].token.description` into other tokens,
+ * and populates the spec.{tag, name, type, description}. Invoked in a chaing
+ * with other tokens, operations listed above can be moved to separate tokenizers
+ */
+export type Tokenizer = (spec: Spec) => Spec;

node_modules/comment-parser/es6/parser/tokenizers/index.js

@@ -0,0 +1 @@
+export {};

node_modules/comment-parser/es6/parser/tokenizers/name.d.ts

@@ -0,0 +1,6 @@
+import { Tokenizer } from './index.js';
+/**
+ * Splits remaining `spec.lines[].tokens.description` into `name` and `descriptions` tokens,
+ * and populates the `spec.name`
+ */
+export default function nameTokenizer(): Tokenizer;

node_modules/comment-parser/es6/parser/tokenizers/name.js

@@ -0,0 +1,91 @@
+import { splitSpace, isSpace } from '../../util.js';
+const isQuoted = (s) => s && s.startsWith('"') && s.endsWith('"');
+/**
+ * Splits remaining `spec.lines[].tokens.description` into `name` and `descriptions` tokens,
+ * and populates the `spec.name`
+ */
+export default function nameTokenizer() {
+    const typeEnd = (num, { tokens }, i) => tokens.type === '' ? num : i;
+    return (spec) => {
+        // look for the name in the line where {type} ends
+        const { tokens } = spec.source[spec.source.reduce(typeEnd, 0)];
+        const source = tokens.description.trimLeft();
+        const quotedGroups = source.split('"');
+        // if it starts with quoted group, assume it is a literal
+        if (quotedGroups.length > 1 &&
+            quotedGroups[0] === '' &&
+            quotedGroups.length % 2 === 1) {
+            spec.name = quotedGroups[1];
+            tokens.name = `"${quotedGroups[1]}"`;
+            [tokens.postName, tokens.description] = splitSpace(source.slice(tokens.name.length));
+            return spec;
+        }
+        let brackets = 0;
+        let name = '';
+        let optional = false;
+        let defaultValue;
+        // assume name is non-space string or anything wrapped into brackets
+        for (const ch of source) {
+            if (brackets === 0 && isSpace(ch))
+                break;
+            if (ch === '[')
+                brackets++;
+            if (ch === ']')
+                brackets--;
+            name += ch;
+        }
+        if (brackets !== 0) {
+            spec.problems.push({
+                code: 'spec:name:unpaired-brackets',
+                message: 'unpaired brackets',
+                line: spec.source[0].number,
+                critical: true,
+            });
+            return spec;
+        }
+        const nameToken = name;
+        if (name[0] === '[' && name[name.length - 1] === ']') {
+            optional = true;
+            name = name.slice(1, -1);
+            const parts = name.split('=');
+            name = parts[0].trim();
+            if (parts[1] !== undefined)
+                defaultValue = parts.slice(1).join('=').trim();
+            if (name === '') {
+                spec.problems.push({
+                    code: 'spec:name:empty-name',
+                    message: 'empty name',
+                    line: spec.source[0].number,
+                    critical: true,
+                });
+                return spec;
+            }
+            if (defaultValue === '') {
+                spec.problems.push({
+                    code: 'spec:name:empty-default',
+                    message: 'empty default value',
+                    line: spec.source[0].number,
+                    critical: true,
+                });
+                return spec;
+            }
+            // has "=" and is not a string, except for "=>"
+            if (!isQuoted(defaultValue) && /=(?!>)/.test(defaultValue)) {
+                spec.problems.push({
+                    code: 'spec:name:invalid-default',
+                    message: 'invalid default value syntax',
+                    line: spec.source[0].number,
+                    critical: true,
+                });
+                return spec;
+            }
+        }
+        spec.optional = optional;
+        spec.name = name;
+        tokens.name = nameToken;
+        if (defaultValue !== undefined)
+            spec.default = defaultValue;
+        [tokens.postName, tokens.description] = splitSpace(source.slice(tokens.name.length));
+        return spec;
+    };
+}

node_modules/comment-parser/es6/parser/tokenizers/tag.d.ts

@@ -0,0 +1,6 @@
+import { Tokenizer } from './index.js';
+/**
+ * Splits the `@prefix` from remaining `Spec.lines[].token.description` into the `tag` token,
+ * and populates `spec.tag`
+ */
+export default function tagTokenizer(): Tokenizer;

node_modules/comment-parser/es6/parser/tokenizers/tag.js

@@ -0,0 +1,24 @@
+/**
+ * Splits the `@prefix` from remaining `Spec.lines[].token.description` into the `tag` token,
+ * and populates `spec.tag`
+ */
+export default function tagTokenizer() {
+    return (spec) => {
+        const { tokens } = spec.source[0];
+        const match = tokens.description.match(/\s*(@(\S+))(\s*)/);
+        if (match === null) {
+            spec.problems.push({
+                code: 'spec:tag:prefix',
+                message: 'tag should start with "@" symbol',
+                line: spec.source[0].number,
+                critical: true,
+            });
+            return spec;
+        }
+        tokens.tag = match[1];
+        tokens.postTag = match[3];
+        tokens.description = tokens.description.slice(match[0].length);
+        spec.tag = match[2];
+        return spec;
+    };
+}

node_modules/comment-parser/es6/parser/tokenizers/type.d.ts

@@ -0,0 +1,27 @@
+import { Tokenizer } from './index.js';
+/**
+ * Joiner is a function taking collected type token string parts,
+ * and joining them together. In most of the cases this will be
+ * a single piece like {type-name}, but type may go over multipe line
+ * ```
+ * @tag {function(
+ *   number,
+ *   string
+ * )}
+ * ```
+ */
+export type Joiner = (parts: string[]) => string;
+/**
+ * Shortcut for standard Joiners
+ * compact - trim surrounding space, replace line breaks with a single space
+ * preserve - concat as is
+ */
+export type Spacing = 'compact' | 'preserve' | Joiner;
+/**
+ * Sets splits remaining `Spec.lines[].tokes.description` into `type` and `description`
+ * tokens and populates Spec.type`
+ *
+ * @param {Spacing} spacing tells how to deal with a whitespace
+ * for type values going over multiple lines
+ */
+export default function typeTokenizer(spacing?: Spacing): Tokenizer;

node_modules/comment-parser/es6/parser/tokenizers/type.js

@@ -0,0 +1,65 @@
+import { splitSpace } from '../../util.js';
+/**
+ * Sets splits remaining `Spec.lines[].tokes.description` into `type` and `description`
+ * tokens and populates Spec.type`
+ *
+ * @param {Spacing} spacing tells how to deal with a whitespace
+ * for type values going over multiple lines
+ */
+export default function typeTokenizer(spacing = 'compact') {
+    const join = getJoiner(spacing);
+    return (spec) => {
+        let curlies = 0;
+        let lines = [];
+        for (const [i, { tokens }] of spec.source.entries()) {
+            let type = '';
+            if (i === 0 && tokens.description[0] !== '{')
+                return spec;
+            for (const ch of tokens.description) {
+                if (ch === '{')
+                    curlies++;
+                if (ch === '}')
+                    curlies--;
+                type += ch;
+                if (curlies === 0)
+                    break;
+            }
+            lines.push([tokens, type]);
+            if (curlies === 0)
+                break;
+        }
+        if (curlies !== 0) {
+            spec.problems.push({
+                code: 'spec:type:unpaired-curlies',
+                message: 'unpaired curlies',
+                line: spec.source[0].number,
+                critical: true,
+            });
+            return spec;
+        }
+        const parts = [];
+        const offset = lines[0][0].postDelimiter.length;
+        for (const [i, [tokens, type]] of lines.entries()) {
+            tokens.type = type;
+            if (i > 0) {
+                tokens.type = tokens.postDelimiter.slice(offset) + type;
+                tokens.postDelimiter = tokens.postDelimiter.slice(0, offset);
+            }
+            [tokens.postType, tokens.description] = splitSpace(tokens.description.slice(type.length));
+            parts.push(tokens.type);
+        }
+        parts[0] = parts[0].slice(1);
+        parts[parts.length - 1] = parts[parts.length - 1].slice(0, -1);
+        spec.type = join(parts);
+        return spec;
+    };
+}
+const trim = (x) => x.trim();
+function getJoiner(spacing) {
+    if (spacing === 'compact')
+        return (t) => t.map(trim).join('');
+    else if (spacing === 'preserve')
+        return (t) => t.join('\n');
+    else
+        return spacing;
+}