@wildboar/asn1-parser 1.0.2

package/dist/lib/parsers/generic/recyclingSequenceOf.mjs

@@ -0,0 +1,55 @@
+import sequenceOf from './sequenceOf.mjs';
+import Parser from '../../Parser.mjs';
+import Production from '../../Production.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Efficiently parse sequences with optional trailing components.
+ * @description
+ * This parser factory generates a parser that does not re-parse sequences that
+ * it has already read successfully.
+ *
+ * For this parser to succeed, it must read the first sequence correctly, but
+ * the trailing ones are optional.
+ *
+ * @param {ProductionType} containingType The type of the `Production` by which
+ *  all of the component CSTs will be subsumed as children.
+ * @param {Parser[][]} parserSets An array of arrays of parsers. The first must
+ *  be parsed successfully for this parser to succeed, but the trailing
+ *  sequences are optional.
+ * @returns A Parser that will not re-parse sequences that have already been
+ *  parsed successfully.
+ */
+export default function (containingType, ...parserSets) {
+    return new Parser(() => `${containingType} Sequence`, (state) => {
+        let previousState = state;
+        const results = [];
+        const sequenceParsers = parserSets.map((ps) => sequenceOf(containingType, ps));
+        if (sequenceParsers.length === 0) {
+            throw new Error();
+        }
+        // At least the first one must parse successfully.
+        const result = sequenceParsers[0].execute(previousState);
+        if (result.error) {
+            return {
+                ...state,
+                error: true,
+            };
+        }
+        results.push(result);
+        previousState = result;
+        // The rest can fail.
+        for (const sp of sequenceParsers.slice(1)) {
+            const result = sp.execute(previousState);
+            if (result.error) {
+                break;
+            }
+            results.push(result);
+            previousState = result;
+        }
+        return {
+            ...previousState,
+            cst: new Production(containingType, results.flatMap((r) => r.cst.children)),
+        };
+    });
+}
+//# sourceMappingURL=recyclingSequenceOf.mjs.map

package/dist/lib/parsers/generic/recyclingSequenceOf.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recyclingSequenceOf.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/recyclingSequenceOf.mts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,kBAAkB,CAAC;AAC1C,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAEtC,OAAO,UAAU,MAAM,sBAAsB,CAAC;AAC9C,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,OAAO,WACZ,cAA8B,EAC9B,GAAG,UAAsB;IAEzB,OAAO,IAAI,MAAM,CACf,GAAG,EAAE,CAAC,GAAG,cAAc,WAAW,EAClC,CAAC,KAAmB,EAAgB,EAAE;QACpC,IAAI,aAAa,GAAG,KAAK,CAAC;QAC1B,MAAM,OAAO,GAAmB,EAAE,CAAC;QACnC,MAAM,eAAe,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAC5C,UAAU,CAAC,cAAc,EAAE,EAAE,CAAC,CAC/B,CAAC;QACF,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,EAAE,CAAC;QACpB,CAAC;QAED,kDAAkD;QAClD,MAAM,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;QACzD,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;YACjB,OAAO;gBACL,GAAG,KAAK;gBACR,KAAK,EAAE,IAAI;aACZ,CAAC;QACJ,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACrB,aAAa,GAAG,MAAM,CAAC;QAEvB,qBAAqB;QACrB,KAAK,MAAM,EAAE,IAAI,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YAC1C,MAAM,MAAM,GAAG,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;YACzC,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;gBACjB,MAAM;YACR,CAAC;YACD,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACrB,aAAa,GAAG,MAAM,CAAC;QACzB,CAAC;QAED,OAAO;YACL,GAAG,aAAa;YAChB,GAAG,EAAE,IAAI,UAAU,CACjB,cAAc,EACd,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CACvC;SACF,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/lib/parsers/generic/repeatable.d.mts

@@ -0,0 +1,17 @@
+import Parser from '../../Parser.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Parse any number of something.
+ * @description
+ * This parser repeatedly parses the input with the `Parser` supplied as the
+ * `parser` argument. When no more parsing can be done with this parser, the
+ * `Parser` produced by this function returns all of the parsed repetitions
+ * as children of a parent `Production` whose type is `containingType`.
+ * @param {ProductionType} containingType The type of the parent `Production`
+ *  that will subsume all repetitions as children.
+ * @param {Parser} parser The `Parser` that will parse individual repetitions.
+ * @returns {Parser} The `Parser` that will parse any number of items parseable
+ *  by the `parser`.
+ */
+export default function (containingType: ProductionType, parser: Parser): Parser;
+//# sourceMappingURL=repeatable.d.mts.map

package/dist/lib/parsers/generic/repeatable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repeatable.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/repeatable.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAGtC,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,OAAO,WACZ,cAAc,EAAE,cAAc,EAC9B,MAAM,EAAE,MAAM,GACb,MAAM,CA2BR"}

package/dist/lib/parsers/generic/repeatable.mjs

@@ -0,0 +1,42 @@
+import Parser from '../../Parser.mjs';
+import Production from '../../Production.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Parse any number of something.
+ * @description
+ * This parser repeatedly parses the input with the `Parser` supplied as the
+ * `parser` argument. When no more parsing can be done with this parser, the
+ * `Parser` produced by this function returns all of the parsed repetitions
+ * as children of a parent `Production` whose type is `containingType`.
+ * @param {ProductionType} containingType The type of the parent `Production`
+ *  that will subsume all repetitions as children.
+ * @param {Parser} parser The `Parser` that will parse individual repetitions.
+ * @returns {Parser} The `Parser` that will parse any number of items parseable
+ *  by the `parser`.
+ */
+export default function (containingType, parser) {
+    return new Parser(() => `${containingType} / Repeatable ${parser.name()}`, (state) => {
+        const children = [];
+        state.log.debug(`Repeatable index: ${state.index}.`);
+        let result = state;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            result = parser.execute(result);
+            if (result.error) {
+                break;
+            }
+            state.log.debug(`Read optional repeatable ${result.cst.type}.`);
+            children.push(result.cst);
+            if (result.index >= result.tokens.length) {
+                break;
+            }
+        }
+        return {
+            ...state,
+            error: children.length === 0,
+            index: result.index,
+            cst: new Production(containingType, children),
+        };
+    });
+}
+//# sourceMappingURL=repeatable.mjs.map

package/dist/lib/parsers/generic/repeatable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"repeatable.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/repeatable.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAEtC,OAAO,UAAU,MAAM,sBAAsB,CAAC;AAC9C,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,OAAO,WACZ,cAA8B,EAC9B,MAAc;IAEd,OAAO,IAAI,MAAM,CACf,GAAG,EAAE,CAAC,GAAG,cAAc,iBAAiB,MAAM,CAAC,IAAI,EAAE,EAAE,EACvD,CAAC,KAAmB,EAAgB,EAAE;QACpC,MAAM,QAAQ,GAAiB,EAAE,CAAC;QAClC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,qBAAqB,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC;QACrD,IAAI,MAAM,GAAG,KAAK,CAAC;QACnB,iDAAiD;QACjD,OAAO,IAAI,EAAE,CAAC;YACZ,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAChC,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;gBACjB,MAAM;YACR,CAAC;YACD,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,4BAA4B,MAAM,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC;YAChE,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC1B,IAAI,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;gBACzC,MAAM;YACR,CAAC;QACH,CAAC;QACD,OAAO;YACL,GAAG,KAAK;YACR,KAAK,EAAE,QAAQ,CAAC,MAAM,KAAK,CAAC;YAC5B,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,GAAG,EAAE,IAAI,UAAU,CAAC,cAAc,EAAE,QAAQ,CAAC;SAC9C,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/lib/parsers/generic/sequenceOf.d.mts

@@ -0,0 +1,2 @@
+export { default as default } from './whitespaceIntolerantSequenceOf.mjs';
+//# sourceMappingURL=sequenceOf.d.mts.map

package/dist/lib/parsers/generic/sequenceOf.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequenceOf.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/sequenceOf.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,sCAAsC,CAAC"}

package/dist/lib/parsers/generic/sequenceOf.mjs

@@ -0,0 +1,2 @@
+export { default as default } from './whitespaceIntolerantSequenceOf.mjs';
+//# sourceMappingURL=sequenceOf.mjs.map

package/dist/lib/parsers/generic/sequenceOf.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequenceOf.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/sequenceOf.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,sCAAsC,CAAC"}

package/dist/lib/parsers/generic/valueParser.d.mts

@@ -0,0 +1,32 @@
+import Parser from '../../Parser.mjs';
+import TypeType from '../../constructs/TypeType.mjs';
+/**
+ * @summary Parse a `Value` according to the expected ASN.1 type.
+ * @description
+ * This parser factory returns a `Parser` that will intelligently use the
+ * ASN.1 data type indicated by `typeType` to select the right parsers to try
+ * to parse a `Value`.
+ *
+ * This is important, because in ASN.1, several values of different types are
+ * syntatically indistinguishable. For example, an empty pair of curly brackets,
+ * `{}` could be a value of any of these types (inclusively):
+ *
+ * - `BIT STRING`
+ * - `OCTET STRING`
+ * - `SET OF`
+ * - `SEQUENCE OF`
+ * - `SET`
+ * - `SEQUENCE`
+ * - `CharacterString`
+ *
+ * For that reason, it is critical to intelligently parse according to the
+ * expected data type.
+ *
+ * @param {TypeType} typeType The ASN.1 type that will be used to determine what
+ *  parsers to use to attempt to parse a `Value`.
+ * @returns {Parser} A `Parser` that will intelligently use only type-compatible
+ *  parsers to parse a `Value`.
+ * @function
+ */
+export default function (typeType: TypeType): Parser;
+//# sourceMappingURL=valueParser.d.mts.map

package/dist/lib/parsers/generic/valueParser.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueParser.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/valueParser.mts"],"names":[],"mappings":"AAEA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAGtC,OAAO,QAAQ,MAAM,+BAA+B,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,OAAO,WAAW,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAenD"}

package/dist/lib/parsers/generic/valueParser.mjs

@@ -0,0 +1,45 @@
+import { choiceOf, aliasFor } from '../generic/index.mjs';
+import ProductionType from '../../ProductionType.mjs';
+import Parser from '../../Parser.mjs';
+import typeTypeToValueParserMap from '../../maps/typeTypeToValueParserMap.mjs';
+import * as parserFor from '../specific/index.mjs';
+import TypeType from '../../constructs/TypeType.mjs';
+/**
+ * @summary Parse a `Value` according to the expected ASN.1 type.
+ * @description
+ * This parser factory returns a `Parser` that will intelligently use the
+ * ASN.1 data type indicated by `typeType` to select the right parsers to try
+ * to parse a `Value`.
+ *
+ * This is important, because in ASN.1, several values of different types are
+ * syntatically indistinguishable. For example, an empty pair of curly brackets,
+ * `{}` could be a value of any of these types (inclusively):
+ *
+ * - `BIT STRING`
+ * - `OCTET STRING`
+ * - `SET OF`
+ * - `SEQUENCE OF`
+ * - `SET`
+ * - `SEQUENCE`
+ * - `CharacterString`
+ *
+ * For that reason, it is critical to intelligently parse according to the
+ * expected data type.
+ *
+ * @param {TypeType} typeType The ASN.1 type that will be used to determine what
+ *  parsers to use to attempt to parse a `Value`.
+ * @returns {Parser} A `Parser` that will intelligently use only type-compatible
+ *  parsers to parse a `Value`.
+ * @function
+ */
+export default function (typeType) {
+    const typeSpecificParser = typeTypeToValueParserMap.get(typeType);
+    return typeSpecificParser
+        ? choiceOf([
+            parserFor.ObjectClassFieldValue,
+            aliasFor(ProductionType.BuiltinValue, typeSpecificParser),
+            parserFor.ReferencedValue,
+        ], ProductionType.Value)
+        : choiceOf([parserFor.ObjectClassFieldValue, parserFor.ReferencedValue], ProductionType.Value);
+}
+//# sourceMappingURL=valueParser.mjs.map

package/dist/lib/parsers/generic/valueParser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueParser.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/valueParser.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,cAAc,MAAM,0BAA0B,CAAC;AACtD,OAAO,MAAM,MAAM,kBAAkB,CAAC;AACtC,OAAO,wBAAwB,MAAM,yCAAyC,CAAC;AAC/E,OAAO,KAAK,SAAS,MAAM,uBAAuB,CAAC;AACnD,OAAO,QAAQ,MAAM,+BAA+B,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,OAAO,WAAW,QAAkB;IACzC,MAAM,kBAAkB,GAAG,wBAAwB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAClE,OAAO,kBAAkB;QACvB,CAAC,CAAC,QAAQ,CACN;YACE,SAAS,CAAC,qBAAqB;YAC/B,QAAQ,CAAC,cAAc,CAAC,YAAY,EAAE,kBAAkB,CAAC;YACzD,SAAS,CAAC,eAAe;SAC1B,EACD,cAAc,CAAC,KAAK,CACrB;QACH,CAAC,CAAC,QAAQ,CACN,CAAC,SAAS,CAAC,qBAAqB,EAAE,SAAS,CAAC,eAAe,CAAC,EAC5D,cAAc,CAAC,KAAK,CACrB,CAAC;AACR,CAAC"}

package/dist/lib/parsers/generic/whitespace.d.mts

@@ -0,0 +1,18 @@
+import Parser from '../../Parser.mjs';
+/**
+ * @summary Parse any whitespace.
+ * @description
+ * This parser parses any number of any whitespace characters recognized by the
+ * ASN.1 specifications.
+ *
+ * Even though whitespace is really just a repeatable choice between
+ * `newlineWhitespace` and `nonNewlineWhitespace`, I implemented a custom
+ * parser for it, just because whitespace is so common that any performance
+ * gains will be monumental. In one file, using this custom parser cut down
+ * parsing time by 20%.
+ *
+ * @constant
+ */
+declare const _default: Parser;
+export default _default;
+//# sourceMappingURL=whitespace.d.mts.map

package/dist/lib/parsers/generic/whitespace.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whitespace.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/whitespace.mts"],"names":[],"mappings":"AACA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAItC;;;;;;;;;;;;;GAaG;;AACH,wBA+BE"}

package/dist/lib/parsers/generic/whitespace.mjs

@@ -0,0 +1,43 @@
+import ProductionType from '../../ProductionType.mjs';
+import Parser from '../../Parser.mjs';
+import Production from '../../Production.mjs';
+/**
+ * @summary Parse any whitespace.
+ * @description
+ * This parser parses any number of any whitespace characters recognized by the
+ * ASN.1 specifications.
+ *
+ * Even though whitespace is really just a repeatable choice between
+ * `newlineWhitespace` and `nonNewlineWhitespace`, I implemented a custom
+ * parser for it, just because whitespace is so common that any performance
+ * gains will be monumental. In one file, using this custom parser cut down
+ * parsing time by 20%.
+ *
+ * @constant
+ */
+export default new Parser(() => 'whitespace', (state) => {
+    let endIndex = state.index;
+    let currentToken = state.tokens[endIndex];
+    while (endIndex < state.tokens.length &&
+        (currentToken.type === ProductionType.newlineWhitespace ||
+            currentToken.type === ProductionType.nonNewlineWhitespace)) {
+        currentToken = state.tokens[++endIndex];
+    }
+    if (endIndex > state.index) {
+        // Tokens were read.
+        return {
+            ...state,
+            error: undefined,
+            index: endIndex,
+            cst: new Production(ProductionType.whitespace, state.tokens.slice(state.index, endIndex)),
+        };
+    }
+    else {
+        return {
+            ...state,
+            error: true,
+            cst: new Production(ProductionType.whitespace, []),
+        };
+    }
+});
+//# sourceMappingURL=whitespace.mjs.map

package/dist/lib/parsers/generic/whitespace.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"whitespace.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/whitespace.mts"],"names":[],"mappings":"AAAA,OAAO,cAAc,MAAM,0BAA0B,CAAC;AACtD,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAEtC,OAAO,UAAU,MAAM,sBAAsB,CAAC;AAE9C;;;;;;;;;;;;;GAaG;AACH,eAAe,IAAI,MAAM,CACvB,GAAW,EAAE,CAAC,YAAY,EAC1B,CAAC,KAAmB,EAAgB,EAAE;IACpC,IAAI,QAAQ,GAAW,KAAK,CAAC,KAAK,CAAC;IACnC,IAAI,YAAY,GAAe,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACtD,OACE,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM;QAC9B,CAAC,YAAY,CAAC,IAAI,KAAK,cAAc,CAAC,iBAAiB;YACrD,YAAY,CAAC,IAAI,KAAK,cAAc,CAAC,oBAAoB,CAAC,EAC5D,CAAC;QACD,YAAY,GAAG,KAAK,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,CAAC;IAC1C,CAAC;IACD,IAAI,QAAQ,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC;QAC3B,oBAAoB;QACpB,OAAO;YACL,GAAG,KAAK;YACR,KAAK,EAAE,SAAS;YAChB,KAAK,EAAE,QAAQ;YACf,GAAG,EAAE,IAAI,UAAU,CACjB,cAAc,CAAC,UAAU,EACzB,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,QAAQ,CAAC,CAC1C;SACF,CAAC;IACJ,CAAC;SAAM,CAAC;QACN,OAAO;YACL,GAAG,KAAK;YACR,KAAK,EAAE,IAAI;YACX,GAAG,EAAE,IAAI,UAAU,CAAC,cAAc,CAAC,UAAU,EAAE,EAAE,CAAC;SACnD,CAAC;IACJ,CAAC;AACH,CAAC,CACF,CAAC"}

package/dist/lib/parsers/generic/whitespaceDelimitedList.d.mts

@@ -0,0 +1,28 @@
+import type Parser from '../../Parser.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Produce a parser that will parse a whitespace-delimited list of
+ *  arbitrary items.
+ * @description
+ * This parser factory produces a parser that will attempt to parse:
+ *
+ * - A list item, as determined by the `listItemParser`
+ * - Whitespace
+ *
+ * In that order, repeating indefinitely until no such productions can be parsed
+ * from the input. The last item will always be of the type the `listItemParser`
+ * emits; the parser generated by this factory will not consume trailing
+ * whitespace.
+ *
+ * The resulting CSTs of the list productions will all be children of a parent
+ * production whose type will be `containingType`.
+ *
+ * @param {ProductionType} containingType The type of the `Production` that will
+ *  subsume the resulting CST.
+ * @param {Parser} listItemParser The parser that will parse items of the list.
+ * @returns {Parser} A `Parser` that will parse a whitespace-delimited list,
+ *  whose list items can be parsed with `listItemParser`.
+ * @function
+ */
+export default function (containingType: ProductionType, listItemParser: Parser): Parser;
+//# sourceMappingURL=whitespaceDelimitedList.d.mts.map

package/dist/lib/parsers/generic/whitespaceDelimitedList.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whitespaceDelimitedList.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/whitespaceDelimitedList.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAE3C,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,OAAO,WACZ,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,MAAM,GACrB,MAAM,CAER"}

package/dist/lib/parsers/generic/whitespaceDelimitedList.mjs

@@ -0,0 +1,31 @@
+import whitespaceIntolerantList from './whitespaceIntolerantList.mjs';
+import whitespace from './whitespace.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Produce a parser that will parse a whitespace-delimited list of
+ *  arbitrary items.
+ * @description
+ * This parser factory produces a parser that will attempt to parse:
+ *
+ * - A list item, as determined by the `listItemParser`
+ * - Whitespace
+ *
+ * In that order, repeating indefinitely until no such productions can be parsed
+ * from the input. The last item will always be of the type the `listItemParser`
+ * emits; the parser generated by this factory will not consume trailing
+ * whitespace.
+ *
+ * The resulting CSTs of the list productions will all be children of a parent
+ * production whose type will be `containingType`.
+ *
+ * @param {ProductionType} containingType The type of the `Production` that will
+ *  subsume the resulting CST.
+ * @param {Parser} listItemParser The parser that will parse items of the list.
+ * @returns {Parser} A `Parser` that will parse a whitespace-delimited list,
+ *  whose list items can be parsed with `listItemParser`.
+ * @function
+ */
+export default function (containingType, listItemParser) {
+    return whitespaceIntolerantList(containingType, listItemParser, whitespace);
+}
+//# sourceMappingURL=whitespaceDelimitedList.mjs.map

package/dist/lib/parsers/generic/whitespaceDelimitedList.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"whitespaceDelimitedList.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/whitespaceDelimitedList.mts"],"names":[],"mappings":"AAAA,OAAO,wBAAwB,MAAM,gCAAgC,CAAC;AAEtE,OAAO,UAAU,MAAM,kBAAkB,CAAC;AAC1C,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,OAAO,WACZ,cAA8B,EAC9B,cAAsB;IAEtB,OAAO,wBAAwB,CAAC,cAAc,EAAE,cAAc,EAAE,UAAU,CAAC,CAAC;AAC9E,CAAC"}

package/dist/lib/parsers/generic/whitespaceIntolerantList.d.mts

@@ -0,0 +1,28 @@
+import Parser from '../../Parser.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Parse a list of items that does not tolerate whitespace between
+ *  delimiters and items.
+ * @description
+ * This parser factory produces a `Parser` that will parse a list of items. The
+ * items must be parseable by `listItemParser`, and the delimiters must be
+ * parseable by `delimiterParser` for the produced `Parser` to succeed.
+ *
+ * The produced `Parser` will not tolerate whitespace between list items and
+ * their delimiters.
+ *
+ * Note that whitespace itself could be used as the delimiter. This is noted
+ * because this technique is already in use in this library.
+ *
+ * @param {ProductionType} containingType The type of the `Production` that will
+ *  subsume all parsed items of the list as children.
+ * @param {Parser} listItemParser The `Parser` that will parse individual items
+ *  of the list.
+ * @param {Parser} delimiterParser The `Parser` that will parse the items that
+ *  are used only syntactically to separate the semantic items of the list.
+ * @returns {Parser} A `Parser` that will read a list of items parseable by
+ *  `listItemParser` with delimiters parseable by `listItemParser`.
+ * @function
+ */
+export default function (containingType: ProductionType, listItemParser: Parser, delimiterParser: Parser): Parser;
+//# sourceMappingURL=whitespaceIntolerantList.d.mts.map

package/dist/lib/parsers/generic/whitespaceIntolerantList.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whitespaceIntolerantList.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/whitespaceIntolerantList.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAGtC,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,OAAO,WACZ,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,GACtB,MAAM,CA+CR"}

package/dist/lib/parsers/generic/whitespaceIntolerantList.mjs

@@ -0,0 +1,65 @@
+import Parser from '../../Parser.mjs';
+import Production from '../../Production.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Parse a list of items that does not tolerate whitespace between
+ *  delimiters and items.
+ * @description
+ * This parser factory produces a `Parser` that will parse a list of items. The
+ * items must be parseable by `listItemParser`, and the delimiters must be
+ * parseable by `delimiterParser` for the produced `Parser` to succeed.
+ *
+ * The produced `Parser` will not tolerate whitespace between list items and
+ * their delimiters.
+ *
+ * Note that whitespace itself could be used as the delimiter. This is noted
+ * because this technique is already in use in this library.
+ *
+ * @param {ProductionType} containingType The type of the `Production` that will
+ *  subsume all parsed items of the list as children.
+ * @param {Parser} listItemParser The `Parser` that will parse individual items
+ *  of the list.
+ * @param {Parser} delimiterParser The `Parser` that will parse the items that
+ *  are used only syntactically to separate the semantic items of the list.
+ * @returns {Parser} A `Parser` that will read a list of items parseable by
+ *  `listItemParser` with delimiters parseable by `listItemParser`.
+ * @function
+ */
+export default function (containingType, listItemParser, delimiterParser) {
+    return new Parser(() => `Delimited List ${containingType}`, (state) => {
+        let nextState = listItemParser.execute(state);
+        if (nextState.error) {
+            state.log.debug(`Could not read first ${nextState.cst.type} list item for ${containingType}.`);
+            return {
+                ...state,
+                error: true,
+                cst: new Production(containingType, []),
+            };
+        }
+        let children = [nextState.cst];
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const delimiter = delimiterParser.execute(nextState);
+            if (delimiter.error) {
+                break;
+            }
+            state.log.debug(`Read ${delimiter.cst.type} delimiter for ${containingType}.`);
+            const listItem = listItemParser.execute(delimiter);
+            if (listItem.error) {
+                break;
+            }
+            state.log.debug(`Read ${listItem.cst.type} list item for ${containingType}.`);
+            nextState = listItem;
+            children = children.concat([delimiter.cst, listItem.cst]);
+            if (nextState.index >= nextState.tokens.length) {
+                break;
+            }
+        }
+        return {
+            ...state,
+            index: nextState.index,
+            cst: new Production(containingType, children),
+        };
+    });
+}
+//# sourceMappingURL=whitespaceIntolerantList.mjs.map

package/dist/lib/parsers/generic/whitespaceIntolerantList.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"whitespaceIntolerantList.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/whitespaceIntolerantList.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAEtC,OAAO,UAAU,MAAM,sBAAsB,CAAC;AAC9C,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,OAAO,WACZ,cAA8B,EAC9B,cAAsB,EACtB,eAAuB;IAEvB,OAAO,IAAI,MAAM,CACf,GAAG,EAAE,CAAC,kBAAkB,cAAc,EAAE,EACxC,CAAC,KAAmB,EAAgB,EAAE;QACpC,IAAI,SAAS,GAAiB,cAAc,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAC5D,IAAI,SAAS,CAAC,KAAK,EAAE,CAAC;YACpB,KAAK,CAAC,GAAG,CAAC,KAAK,CACb,wBAAwB,SAAS,CAAC,GAAG,CAAC,IAAI,kBAAkB,cAAc,GAAG,CAC9E,CAAC;YACF,OAAO;gBACL,GAAG,KAAK;gBACR,KAAK,EAAE,IAAI;gBACX,GAAG,EAAE,IAAI,UAAU,CAAC,cAAc,EAAE,EAAE,CAAC;aACxC,CAAC;QACJ,CAAC;QACD,IAAI,QAAQ,GAAiB,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAC7C,iDAAiD;QACjD,OAAO,IAAI,EAAE,CAAC;YACZ,MAAM,SAAS,GAAG,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YACrD,IAAI,SAAS,CAAC,KAAK,EAAE,CAAC;gBACpB,MAAM;YACR,CAAC;YACD,KAAK,CAAC,GAAG,CAAC,KAAK,CACb,QAAQ,SAAS,CAAC,GAAG,CAAC,IAAI,kBAAkB,cAAc,GAAG,CAC9D,CAAC;YAEF,MAAM,QAAQ,GAAG,cAAc,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YACnD,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC;gBACnB,MAAM;YACR,CAAC;YACD,KAAK,CAAC,GAAG,CAAC,KAAK,CACb,QAAQ,QAAQ,CAAC,GAAG,CAAC,IAAI,kBAAkB,cAAc,GAAG,CAC7D,CAAC;YAEF,SAAS,GAAG,QAAQ,CAAC;YACrB,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;YAC1D,IAAI,SAAS,CAAC,KAAK,IAAI,SAAS,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;gBAC/C,MAAM;YACR,CAAC;QACH,CAAC;QACD,OAAO;YACL,GAAG,KAAK;YACR,KAAK,EAAE,SAAS,CAAC,KAAK;YACtB,GAAG,EAAE,IAAI,UAAU,CAAC,cAAc,EAAE,QAAQ,CAAC;SAC9C,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/lib/parsers/generic/whitespaceIntolerantSequenceOf.d.mts

@@ -0,0 +1,19 @@
+import Parser from '../../Parser.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Parse a specific sequence of grammatical productions in order.
+ * @description
+ * A `Parser` generated by this parser factory will parse all of the component
+ * parsers, which are passed in as the parameter `parsers` in the order given.
+ * If any of them fail parsing, the `Parser` generated by this parser factory
+ * will return an error.
+ * @param {ProductionType} containingType The type of the `Production` by which
+ *  all of the component CSTs will be subsumed as children.
+ * @param {Parser[]} parsers The components of the sequence, which will be
+ *  parsed in order.
+ * @returns {Parser} A `Parser` that will parse all of the component parsers
+ *  in order and fail if any of them fail.
+ * @function
+ */
+export default function (containingType: ProductionType, parsers: Parser[]): Parser;
+//# sourceMappingURL=whitespaceIntolerantSequenceOf.d.mts.map

package/dist/lib/parsers/generic/whitespaceIntolerantSequenceOf.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whitespaceIntolerantSequenceOf.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/whitespaceIntolerantSequenceOf.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAGtC,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,WACZ,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,MAAM,EAAE,GAChB,MAAM,CA8CR"}

package/dist/lib/parsers/generic/whitespaceIntolerantSequenceOf.mjs

@@ -0,0 +1,50 @@
+import Parser from '../../Parser.mjs';
+import Production from '../../Production.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Parse a specific sequence of grammatical productions in order.
+ * @description
+ * A `Parser` generated by this parser factory will parse all of the component
+ * parsers, which are passed in as the parameter `parsers` in the order given.
+ * If any of them fail parsing, the `Parser` generated by this parser factory
+ * will return an error.
+ * @param {ProductionType} containingType The type of the `Production` by which
+ *  all of the component CSTs will be subsumed as children.
+ * @param {Parser[]} parsers The components of the sequence, which will be
+ *  parsed in order.
+ * @returns {Parser} A `Parser` that will parse all of the component parsers
+ *  in order and fail if any of them fail.
+ * @function
+ */
+export default function (containingType, parsers) {
+    return new Parser(() => `${containingType} Sequence`, (state) => {
+        if (parsers.length === 0) {
+            return state;
+        }
+        let nextState = state;
+        const results = new Array(parsers.length);
+        for (let i = 0; i < parsers.length; i++) {
+            const result = parsers[i].execute(nextState);
+            if (result.error) {
+                state.log.debug(`Failed to read ${parsers[i].name()} (index ${i}) as part of sequence ${containingType}.`);
+                return {
+                    ...state,
+                    cst: new Production(containingType, results.slice(0, i).map((r) => r.cst)),
+                    error: true,
+                };
+            }
+            else {
+                state.log.debug(`Read ${parsers[i].name()} (index ${i}) as part of sequence ${containingType}.`);
+                nextState = result;
+                results[i] = result;
+            }
+        }
+        return {
+            ...state,
+            tokens: state.tokens,
+            index: nextState.index,
+            cst: new Production(containingType, results.map((r) => r.cst)),
+        };
+    });
+}
+//# sourceMappingURL=whitespaceIntolerantSequenceOf.mjs.map

package/dist/lib/parsers/generic/whitespaceIntolerantSequenceOf.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"whitespaceIntolerantSequenceOf.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/whitespaceIntolerantSequenceOf.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAEtC,OAAO,UAAU,MAAM,sBAAsB,CAAC;AAC9C,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,WACZ,cAA8B,EAC9B,OAAiB;IAEjB,OAAO,IAAI,MAAM,CACf,GAAG,EAAE,CAAC,GAAG,cAAc,WAAW,EAClC,CAAC,KAAmB,EAAgB,EAAE;QACpC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACzB,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,SAAS,GAAiB,KAAK,CAAC;QACpC,MAAM,OAAO,GAAmB,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC1D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YAC7C,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;gBACjB,KAAK,CAAC,GAAG,CAAC,KAAK,CACb,kBAAkB,OAAO,CACvB,CAAC,CACF,CAAC,IAAI,EAAE,WAAW,CAAC,yBAAyB,cAAc,GAAG,CAC/D,CAAC;gBACF,OAAO;oBACL,GAAG,KAAK;oBACR,GAAG,EAAE,IAAI,UAAU,CACjB,cAAc,EACd,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CACtC;oBACD,KAAK,EAAE,IAAI;iBACZ,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,KAAK,CAAC,GAAG,CAAC,KAAK,CACb,QAAQ,OAAO,CACb,CAAC,CACF,CAAC,IAAI,EAAE,WAAW,CAAC,yBAAyB,cAAc,GAAG,CAC/D,CAAC;gBACF,SAAS,GAAG,MAAM,CAAC;gBACnB,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;YACtB,CAAC;QACH,CAAC;QACD,OAAO;YACL,GAAG,KAAK;YACR,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,KAAK,EAAE,SAAS,CAAC,KAAK;YACtB,GAAG,EAAE,IAAI,UAAU,CACjB,cAAc,EACd,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAC1B;SACF,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/lib/parsers/generic/whitespaceOptionalDelimitedList.d.mts

@@ -0,0 +1,17 @@
+import type Parser from '../../Parser.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Parse any number of list items optionally separated by whitespace.
+ * @description
+ * This differs from `whitespaceDelimitedList` in that the whitespace is
+ * optional.
+ * @param {ProductionType} containingType The type of the `Production` that will
+ *  subsume all parsed items of the list as children.
+ * @param {Parser} listItemParser The `Parser` that will parse individual items
+ *  of the list.
+ * @returns {Parser} A `Parser` that will parse one or more list items that may
+ *  be separated by whitespace.
+ * @function
+ */
+export default function (containingType: ProductionType, listItemParser: Parser): Parser;
+//# sourceMappingURL=whitespaceOptionalDelimitedList.d.mts.map

package/dist/lib/parsers/generic/whitespaceOptionalDelimitedList.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whitespaceOptionalDelimitedList.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/whitespaceOptionalDelimitedList.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAG3C,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,OAAO,WACZ,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,MAAM,GACrB,MAAM,CAMR"}

package/dist/lib/parsers/generic/whitespaceOptionalDelimitedList.mjs

@@ -0,0 +1,21 @@
+import whitespaceIntolerantList from './whitespaceIntolerantList.mjs';
+import optional from './optional.mjs';
+import whitespace from './whitespace.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Parse any number of list items optionally separated by whitespace.
+ * @description
+ * This differs from `whitespaceDelimitedList` in that the whitespace is
+ * optional.
+ * @param {ProductionType} containingType The type of the `Production` that will
+ *  subsume all parsed items of the list as children.
+ * @param {Parser} listItemParser The `Parser` that will parse individual items
+ *  of the list.
+ * @returns {Parser} A `Parser` that will parse one or more list items that may
+ *  be separated by whitespace.
+ * @function
+ */
+export default function (containingType, listItemParser) {
+    return whitespaceIntolerantList(containingType, listItemParser, optional(whitespace));
+}
+//# sourceMappingURL=whitespaceOptionalDelimitedList.mjs.map

package/dist/lib/parsers/generic/whitespaceOptionalDelimitedList.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"whitespaceOptionalDelimitedList.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/whitespaceOptionalDelimitedList.mts"],"names":[],"mappings":"AAAA,OAAO,wBAAwB,MAAM,gCAAgC,CAAC;AAEtE,OAAO,QAAQ,MAAM,gBAAgB,CAAC;AACtC,OAAO,UAAU,MAAM,kBAAkB,CAAC;AAC1C,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,OAAO,WACZ,cAA8B,EAC9B,cAAsB;IAEtB,OAAO,wBAAwB,CAC7B,cAAc,EACd,cAAc,EACd,QAAQ,CAAC,UAAU,CAAC,CACrB,CAAC;AACJ,CAAC"}

package/dist/lib/parsers/generic/whitespaceTolerantList.d.mts

@@ -0,0 +1,25 @@
+import Parser from '../../Parser.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Parse a list of items that tolerates whitespace between delimiters
+ *  and items.
+ * @description
+ * This parser factory produces a `Parser` that will parse a list of items. The
+ * items must be parseable by `listItemParser`, and the delimiters must be
+ * parseable by `delimiterParser` for the produced `Parser` to succeed.
+ *
+ * The produced `Parser` will tolerate whitespace between list items and their
+ * delimiters.
+ *
+ * @param {ProductionType} containingType The type of the `Production` that will
+ *  subsume all parsed items of the list as children.
+ * @param {Parser} listItemParser The `Parser` that will parse individual items
+ *  of the list.
+ * @param {Parser} delimiterParser The `Parser` that will parse the items that
+ *  are used only syntactically to separate the semantic items of the list.
+ * @returns {Parser} A `Parser` that will read a list of items parseable by
+ *  `listItemParser` with delimiters parseable by `listItemParser`.
+ * @function
+ */
+export default function (containingType: ProductionType, listItemParser: Parser, delimiterParser: Parser): Parser;
+//# sourceMappingURL=whitespaceTolerantList.d.mts.map