@wildboar/asn1-parser 1.0.2

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

@@ -0,0 +1,41 @@
+import Parser from '../../Parser.mjs';
+import anythingUntil from './anythingUntil.mjs';
+import ProductionType from '../../ProductionType.mjs';
+import ASN1SyntaxError from '../../errors/ASN1SyntaxError.mjs';
+/**
+ * @summary Produce a `Parser` that will produce a syntax error if it fails.
+ * @description
+ * This parser will attempt to parse with the `asserted` parser, and if that
+ * fails, it will fast-forward through tokens until the `recovery` parser
+ * succeeds.
+ *
+ * This is for scenarios where a parsing syntax could be said with certainty to
+ * be incorrect a run time. For instance, when parsing an `ExtensionDefault`,
+ * the ASN.1 keyword `EXTENSIBILITY` must always be followed by an `IMPLIED`, so
+ * if `EXTENSIBILITY` is encountered, the subsequent `IMPLIED` can be asserted
+ * with a parser produced by this function.
+ *
+ * @param {Parser} asserted The parser whose success is to be asserted.
+ * @param {Parser} recovery The parser to fast-forward to in case of a failed
+ *  assertion so the parsing state can "re-align."
+ * @param {string} uuid A UUID to uniquely identify the assertion error.
+ * @returns {Parser} The parser that will assert the `asserted` parser.
+ * @function
+ */
+export default function (asserted, recovery, uuid) {
+    return new Parser(() => 'Assertion', (state) => {
+        const result = asserted.execute(state);
+        if (result.error) {
+            const recoveryResult = anythingUntil(ProductionType.SYNTAX_ERROR, recovery).execute(state);
+            const key = result.cst.location.startIndex;
+            if (!(key in recoveryResult.syntaxErrors)) {
+                recoveryResult.syntaxErrors[key] = new ASN1SyntaxError(recoveryResult.cst, `urn:uuid:${uuid}: Required production '${asserted.name()}' not found.`);
+            }
+            return recoveryResult;
+        }
+        else {
+            return result;
+        }
+    });
+}
+//# sourceMappingURL=assert.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assert.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/assert.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAEtC,OAAO,aAAa,MAAM,qBAAqB,CAAC;AAChD,OAAO,cAAc,MAAM,0BAA0B,CAAC;AACtD,OAAO,eAAe,MAAM,kCAAkC,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,OAAO,WACZ,QAAgB,EAChB,QAAgB,EAChB,IAAY;IAEZ,OAAO,IAAI,MAAM,CACf,GAAG,EAAE,CAAC,WAAW,EACjB,CAAC,KAAmB,EAAgB,EAAE;QACpC,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACvC,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;YACjB,MAAM,cAAc,GAAG,aAAa,CAClC,cAAc,CAAC,YAAY,EAC3B,QAAQ,CACT,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACjB,MAAM,GAAG,GAAW,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC;YACnD,IAAI,CAAC,CAAC,GAAG,IAAI,cAAc,CAAC,YAAY,CAAC,EAAE,CAAC;gBAC1C,cAAc,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,IAAI,eAAe,CACpD,cAAc,CAAC,GAAG,EAClB,YAAY,IAAI,0BAA0B,QAAQ,CAAC,IAAI,EAAE,cAAc,CACxE,CAAC;YACJ,CAAC;YACD,OAAO,cAAc,CAAC;QACxB,CAAC;aAAM,CAAC;YACN,OAAO,MAAM,CAAC;QAChB,CAAC;IACH,CAAC,CACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,22 @@
+import Parser from '../../Parser.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Produce a `Parser` that attempts multiple alternatives.
+ * @description
+ * This parser factory takes multiple alternatives, and attempts to parse them,
+ * one by one, until one succeeds. The alternative parsers will be attempted in
+ * the order that they were received in the `alts` array. If no matches occur,
+ * the generated parser returns an error to its parent. If parsing succeeds, the
+ * succeeding parser's CST will be returned if `containingType` is not set,
+ * otherwise, another `Production` having type `containingType` will subsume the
+ * CST produced by the succeeding alternative.
+ *
+ * @param {Parser[]} alts The parsers to attempt.
+ * @param {ProductionType} containingType The type of the `Production` that will
+ *  subsume the parsed alternative.
+ * @returns {Parser} A `Parser` that will attempt all of the alternatives and
+ *  return the first successful alternative.
+ * @function
+ */
+export default function (alts: Parser[], containingType?: ProductionType): Parser;
+//# sourceMappingURL=choiceOf.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"choiceOf.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/choiceOf.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAGtC,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,OAAO,WACZ,IAAI,EAAE,MAAM,EAAE,EACd,cAAc,CAAC,EAAE,cAAc,GAC9B,MAAM,CAuCR"}

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

@@ -0,0 +1,55 @@
+import Parser from '../../Parser.mjs';
+import Production from '../../Production.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Produce a `Parser` that attempts multiple alternatives.
+ * @description
+ * This parser factory takes multiple alternatives, and attempts to parse them,
+ * one by one, until one succeeds. The alternative parsers will be attempted in
+ * the order that they were received in the `alts` array. If no matches occur,
+ * the generated parser returns an error to its parent. If parsing succeeds, the
+ * succeeding parser's CST will be returned if `containingType` is not set,
+ * otherwise, another `Production` having type `containingType` will subsume the
+ * CST produced by the succeeding alternative.
+ *
+ * @param {Parser[]} alts The parsers to attempt.
+ * @param {ProductionType} containingType The type of the `Production` that will
+ *  subsume the parsed alternative.
+ * @returns {Parser} A `Parser` that will attempt all of the alternatives and
+ *  return the first successful alternative.
+ * @function
+ */
+export default function (alts, containingType) {
+    return new Parser(() => `${containingType || alts.map((p) => p.name()).join(',')} Choice`, (state) => {
+        for (const labeledParser of alts) {
+            const result = labeledParser.execute(state);
+            if (!result.error) {
+                // This logs as "info" level, because knowing which paths
+                // the Parser takes is especially valuable, with the
+                // exception of whitespace.
+                if (containingType === ProductionType.whitespace) {
+                    state.log.debug(`Read ${containingType || alts.map((p) => p.name()).join(',')} ` +
+                        `alternative ${labeledParser.name()}.`);
+                }
+                else {
+                    state.log.info(`Read ${containingType || alts.map((p) => p.name()).join(',')} ` +
+                        `alternative ${labeledParser.name()}.`);
+                }
+                return {
+                    ...result,
+                    // For some reason, you have to use `state`'s currentType...
+                    currentType: state.currentType,
+                    cst: containingType
+                        ? new Production(containingType || result.cst.type, [result.cst])
+                        : result.cst,
+                };
+            }
+        }
+        return {
+            ...state,
+            error: true,
+            cst: new Production(containingType || ProductionType.empty, []),
+        };
+    });
+}
+//# sourceMappingURL=choiceOf.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"choiceOf.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/choiceOf.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAEtC,OAAO,UAAU,MAAM,sBAAsB,CAAC;AAC9C,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,OAAO,WACZ,IAAc,EACd,cAA+B;IAE/B,OAAO,IAAI,MAAM,CACf,GAAG,EAAE,CAAC,GAAG,cAAc,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,EACvE,CAAC,KAAmB,EAAgB,EAAE;QACpC,KAAK,MAAM,aAAa,IAAI,IAAI,EAAE,CAAC;YACjC,MAAM,MAAM,GAAG,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC5C,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;gBAClB,yDAAyD;gBACzD,oDAAoD;gBACpD,2BAA2B;gBAC3B,IAAI,cAAc,KAAK,cAAc,CAAC,UAAU,EAAE,CAAC;oBACjD,KAAK,CAAC,GAAG,CAAC,KAAK,CACb,QAAQ,cAAc,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG;wBAC9D,eAAe,aAAa,CAAC,IAAI,EAAE,GAAG,CACzC,CAAC;gBACJ,CAAC;qBAAM,CAAC;oBACN,KAAK,CAAC,GAAG,CAAC,IAAI,CACZ,QAAQ,cAAc,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG;wBAC9D,eAAe,aAAa,CAAC,IAAI,EAAE,GAAG,CACzC,CAAC;gBACJ,CAAC;gBAED,OAAO;oBACL,GAAG,MAAM;oBACT,4DAA4D;oBAC5D,WAAW,EAAE,KAAK,CAAC,WAAW;oBAC9B,GAAG,EAAE,cAAc;wBACjB,CAAC,CAAC,IAAI,UAAU,CAAC,cAAc,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;wBACjE,CAAC,CAAC,MAAM,CAAC,GAAG;iBACf,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO;YACL,GAAG,KAAK;YACR,KAAK,EAAE,IAAI;YACX,GAAG,EAAE,IAAI,UAAU,CAAC,cAAc,IAAI,cAAc,CAAC,KAAK,EAAE,EAAE,CAAC;SAChE,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,30 @@
+import Parser from '../../Parser.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Produce a parser that will parse a comma-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`
+ * - An optional whitespace
+ * - A comma
+ * - An optional 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 or commas.
+ *
+ * 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 comma-delimited list, whose
+ *  list items can be parsed with `listItemParser`.
+ * @function
+ */
+export default function (containingType: ProductionType, listItemParser: Parser): Parser;
+//# sourceMappingURL=commaDelimitedList.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"commaDelimitedList.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/commaDelimitedList.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AACtC,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAItD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,OAAO,WACZ,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,MAAM,GACrB,MAAM,CAMR"}

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

@@ -0,0 +1,34 @@
+import Parser from '../../Parser.mjs';
+import ProductionType from '../../ProductionType.mjs';
+import literal from './literal.mjs';
+import whitespaceTolerantList from './whitespaceTolerantList.mjs';
+/**
+ * @summary Produce a parser that will parse a comma-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`
+ * - An optional whitespace
+ * - A comma
+ * - An optional 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 or commas.
+ *
+ * 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 comma-delimited list, whose
+ *  list items can be parsed with `listItemParser`.
+ * @function
+ */
+export default function (containingType, listItemParser) {
+    return whitespaceTolerantList(containingType, listItemParser, literal(ProductionType.comma));
+}
+//# sourceMappingURL=commaDelimitedList.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"commaDelimitedList.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/commaDelimitedList.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AACtC,OAAO,cAAc,MAAM,0BAA0B,CAAC;AACtD,OAAO,OAAO,MAAM,eAAe,CAAC;AACpC,OAAO,sBAAsB,MAAM,8BAA8B,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,OAAO,WACZ,cAA8B,EAC9B,cAAsB;IAEtB,OAAO,sBAAsB,CAC3B,cAAc,EACd,cAAc,EACd,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,CAC9B,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,20 @@
+import type ParseContext from '../../interfaces/ParseContext.mjs';
+import Parser from '../../Parser.mjs';
+/**
+ * @summary Do something when a parser parses successfully.
+ * @description
+ * A `Parser` generated with this factory will call the `callback`, passing in
+ * the parser state as the first an only argument, when the parser indicated by
+ * the `parser` argument parses successfully.
+ *
+ * Whether the `Parser` given by the `parser` parameter fails or not, this
+ * will return its resulting state. This function does not manipulate the
+ * parser state resulint from `parser` at all.
+ *
+ * @param {Parser} parser The `Parser` whose success will trigger the callback.
+ * @param callback The action to be taken when the `parser` succeeds.
+ * @returns {Parser} A `Parser` that will call the callback when the
+ *  parameter `Parser` succeeds.
+ */
+export default function (parser: Parser, callback: (state: ParseContext) => void): Parser;
+//# sourceMappingURL=doif.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"doif.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/doif.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,mCAAmC,CAAC;AAClE,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAEtC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,WACZ,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GACtC,MAAM,CAWR"}

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

@@ -0,0 +1,27 @@
+import Parser from '../../Parser.mjs';
+/**
+ * @summary Do something when a parser parses successfully.
+ * @description
+ * A `Parser` generated with this factory will call the `callback`, passing in
+ * the parser state as the first an only argument, when the parser indicated by
+ * the `parser` argument parses successfully.
+ *
+ * Whether the `Parser` given by the `parser` parameter fails or not, this
+ * will return its resulting state. This function does not manipulate the
+ * parser state resulint from `parser` at all.
+ *
+ * @param {Parser} parser The `Parser` whose success will trigger the callback.
+ * @param callback The action to be taken when the `parser` succeeds.
+ * @returns {Parser} A `Parser` that will call the callback when the
+ *  parameter `Parser` succeeds.
+ */
+export default function (parser, callback) {
+    return new Parser(() => 'Do-If Callback', (state) => {
+        const result = parser.execute(state);
+        if (!result.error) {
+            callback(state);
+        }
+        return result;
+    });
+}
+//# sourceMappingURL=doif.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"doif.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/doif.mts"],"names":[],"mappings":"AACA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAEtC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,WACZ,MAAc,EACd,QAAuC;IAEvC,OAAO,IAAI,MAAM,CACf,GAAG,EAAE,CAAC,gBAAgB,EACtB,CAAC,KAAmB,EAAgB,EAAE;QACpC,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YAClB,QAAQ,CAAC,KAAK,CAAC,CAAC;QAClB,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC,CACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,27 @@
+/**
+ * The ordering of these exports is critical.
+ */
+export { default as aliasFor } from './aliasFor.mjs';
+export { default as anything } from './anything.mjs';
+export { default as anythingExcept } from './anythingExcept.mjs';
+export { default as anythingUntil } from './anythingUntil.mjs';
+export { default as assert } from './assert.mjs';
+export { default as choiceOf } from './choiceOf.mjs';
+export { default as commaDelimitedList } from './commaDelimitedList.mjs';
+export { default as doif } from './doif.mjs';
+export { default as literal } from './literal.mjs';
+export { default as optional } from './optional.mjs';
+export { default as periodDelimitedList } from './periodDelimitedList.mjs';
+export { default as recursiveParser } from './recursiveParser.mjs';
+export { default as repeatable } from './repeatable.mjs';
+export { default as whitespace } from './whitespace.mjs';
+export { default as recyclingSequenceOf } from './recyclingSequenceOf.mjs';
+export { default as sequenceOf } from './sequenceOf.mjs';
+export { default as valueParser } from './valueParser.mjs';
+export { default as whitespaceDelimitedList } from './whitespaceDelimitedList.mjs';
+export { default as whitespaceIntolerantList } from './whitespaceIntolerantList.mjs';
+export { default as whitespaceIntolerantSequenceOf } from './whitespaceIntolerantSequenceOf.mjs';
+export { default as whitespaceOptionalDelimitedList } from './whitespaceOptionalDelimitedList.mjs';
+export { default as whitespaceTolerantList } from './whitespaceTolerantList.mjs';
+export { default as whitespaceTolerantSequenceOf } from './whitespaceTolerantSequenceOf.mjs';
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/index.mts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACnF,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AACrF,OAAO,EAAE,OAAO,IAAI,8BAA8B,EAAE,MAAM,sCAAsC,CAAC;AACjG,OAAO,EAAE,OAAO,IAAI,+BAA+B,EAAE,MAAM,uCAAuC,CAAC;AACnG,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AACjF,OAAO,EAAE,OAAO,IAAI,4BAA4B,EAAE,MAAM,oCAAoC,CAAC"}

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

@@ -0,0 +1,27 @@
+/**
+ * The ordering of these exports is critical.
+ */
+export { default as aliasFor } from './aliasFor.mjs';
+export { default as anything } from './anything.mjs';
+export { default as anythingExcept } from './anythingExcept.mjs';
+export { default as anythingUntil } from './anythingUntil.mjs';
+export { default as assert } from './assert.mjs';
+export { default as choiceOf } from './choiceOf.mjs';
+export { default as commaDelimitedList } from './commaDelimitedList.mjs';
+export { default as doif } from './doif.mjs';
+export { default as literal } from './literal.mjs';
+export { default as optional } from './optional.mjs';
+export { default as periodDelimitedList } from './periodDelimitedList.mjs';
+export { default as recursiveParser } from './recursiveParser.mjs';
+export { default as repeatable } from './repeatable.mjs';
+export { default as whitespace } from './whitespace.mjs';
+export { default as recyclingSequenceOf } from './recyclingSequenceOf.mjs';
+export { default as sequenceOf } from './sequenceOf.mjs';
+export { default as valueParser } from './valueParser.mjs';
+export { default as whitespaceDelimitedList } from './whitespaceDelimitedList.mjs';
+export { default as whitespaceIntolerantList } from './whitespaceIntolerantList.mjs';
+export { default as whitespaceIntolerantSequenceOf } from './whitespaceIntolerantSequenceOf.mjs';
+export { default as whitespaceOptionalDelimitedList } from './whitespaceOptionalDelimitedList.mjs';
+export { default as whitespaceTolerantList } from './whitespaceTolerantList.mjs';
+export { default as whitespaceTolerantSequenceOf } from './whitespaceTolerantSequenceOf.mjs';
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/index.mts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACnF,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AACrF,OAAO,EAAE,OAAO,IAAI,8BAA8B,EAAE,MAAM,sCAAsC,CAAC;AACjG,OAAO,EAAE,OAAO,IAAI,+BAA+B,EAAE,MAAM,uCAAuC,CAAC;AACnG,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AACjF,OAAO,EAAE,OAAO,IAAI,4BAA4B,EAAE,MAAM,oCAAoC,CAAC"}

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

@@ -0,0 +1,16 @@
+import Parser from '../../Parser.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Only parse a token having a specific type.
+ * @description
+ * This parser factory produces a parser that parses a single token, and only
+ * succeeds if that token has exactly the type indicated by `ProductionType`.
+ * @param {ProductionType} type Succeed if the next token has this type.
+ * @param {ProductionType} containingType If success, enclose the token in this
+ *  type.
+ * @returns {Parser} A `Parser` that will succeed only if the next token has the
+ *  type indicated by `type` and optionally encloses it in a parent production.
+ * @function
+ */
+export default function (type: ProductionType, containingType?: ProductionType): Parser;
+//# sourceMappingURL=literal.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"literal.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/literal.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAGtC,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,WACZ,IAAI,EAAE,cAAc,EACpB,cAAc,CAAC,EAAE,cAAc,GAC9B,MAAM,CA6BR"}

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

@@ -0,0 +1,42 @@
+import Parser from '../../Parser.mjs';
+import Production from '../../Production.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Only parse a token having a specific type.
+ * @description
+ * This parser factory produces a parser that parses a single token, and only
+ * succeeds if that token has exactly the type indicated by `ProductionType`.
+ * @param {ProductionType} type Succeed if the next token has this type.
+ * @param {ProductionType} containingType If success, enclose the token in this
+ *  type.
+ * @returns {Parser} A `Parser` that will succeed only if the next token has the
+ *  type indicated by `type` and optionally encloses it in a parent production.
+ * @function
+ */
+export default function (type, containingType) {
+    return new Parser(() => `${containingType || type} Literal`, (state) => {
+        const currentToken = state.tokens[state.index];
+        if (currentToken.type === type) {
+            state.log.debug(`Read single literal ${type} successfully.`);
+            return {
+                ...state,
+                index: state.index + 1,
+                cst: containingType
+                    ? new Production(containingType, [currentToken])
+                    : currentToken,
+            };
+        }
+        else {
+            state.log.debug(`Expected ProductionType ${type}, but got ${currentToken.type}.`);
+            return {
+                ...state,
+                error: true,
+                cst: new Production(containingType ?? type, [], {
+                    ...currentToken.location,
+                    endIndex: currentToken.location.startIndex,
+                }),
+            };
+        }
+    });
+}
+//# sourceMappingURL=literal.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"literal.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/literal.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAEtC,OAAO,UAAU,MAAM,sBAAsB,CAAC;AAC9C,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,WACZ,IAAoB,EACpB,cAA+B;IAE/B,OAAO,IAAI,MAAM,CACf,GAAG,EAAE,CAAC,GAAG,cAAc,IAAI,IAAI,UAAU,EACzC,CAAC,KAAmB,EAAgB,EAAE;QACpC,MAAM,YAAY,GAAe,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC3D,IAAI,YAAY,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YAC/B,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,uBAAuB,IAAI,gBAAgB,CAAC,CAAC;YAC7D,OAAO;gBACL,GAAG,KAAK;gBACR,KAAK,EAAE,KAAK,CAAC,KAAK,GAAG,CAAC;gBACtB,GAAG,EAAE,cAAc;oBACjB,CAAC,CAAC,IAAI,UAAU,CAAC,cAAc,EAAE,CAAC,YAAY,CAAC,CAAC;oBAChD,CAAC,CAAC,YAAY;aACjB,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,GAAG,CAAC,KAAK,CACb,2BAA2B,IAAI,aAAa,YAAY,CAAC,IAAI,GAAG,CACjE,CAAC;YACF,OAAO;gBACL,GAAG,KAAK;gBACR,KAAK,EAAE,IAAI;gBACX,GAAG,EAAE,IAAI,UAAU,CAAC,cAAc,IAAI,IAAI,EAAE,EAAE,EAAE;oBAC9C,GAAG,YAAY,CAAC,QAAQ;oBACxB,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,UAAU;iBAC3C,CAAC;aACH,CAAC;QACJ,CAAC;IACH,CAAC,CACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,15 @@
+import Parser from '../../Parser.mjs';
+/**
+ * @summary Ignore the error if something cannot be parsed.
+ * @description
+ * A parser generated by this parser factory will simply ignore failure (meaning
+ * that it will succeed), even if the contained `parser` fails to parse
+ * successfully. Other than deleting any error, the parser state produced by the
+ * contained parser will be returned unchanged.
+ *
+ * @param {Parser} parser The `Parser` whose failure is to be ignored.
+ * @returns {Parser} A `Parser` that will always succeed.
+ * @function
+ */
+export default function (parser: Parser): Parser;
+//# sourceMappingURL=optional.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"optional.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/optional.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAItC;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,WAAW,MAAM,EAAE,MAAM,GAAG,MAAM,CAW/C"}

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

@@ -0,0 +1,24 @@
+import Parser from '../../Parser.mjs';
+import OptionalParser from '../../OptionalParser.mjs';
+/**
+ * @summary Ignore the error if something cannot be parsed.
+ * @description
+ * A parser generated by this parser factory will simply ignore failure (meaning
+ * that it will succeed), even if the contained `parser` fails to parse
+ * successfully. Other than deleting any error, the parser state produced by the
+ * contained parser will be returned unchanged.
+ *
+ * @param {Parser} parser The `Parser` whose failure is to be ignored.
+ * @returns {Parser} A `Parser` that will always succeed.
+ * @function
+ */
+export default function (parser) {
+    return new OptionalParser(() => `Optional ${parser.name()}`, (state) => {
+        const result = parser.execute(state);
+        if (result.error) {
+            delete result.error;
+        }
+        return result;
+    });
+}
+//# sourceMappingURL=optional.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"optional.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/optional.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AACtC,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAGtD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,WAAW,MAAc;IACrC,OAAO,IAAI,cAAc,CACvB,GAAG,EAAE,CAAC,YAAY,MAAM,CAAC,IAAI,EAAE,EAAE,EACjC,CAAC,KAAmB,EAAgB,EAAE;QACpC,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;YACjB,OAAO,MAAM,CAAC,KAAK,CAAC;QACtB,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC,CACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,30 @@
+import Parser from '../../Parser.mjs';
+import ProductionType from '../../ProductionType.mjs';
+/**
+ * @summary Produce a parser that will parse a period-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`
+ * - An optional whitespace
+ * - A period
+ * - An optional 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 or periods.
+ *
+ * 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 period-delimited list, whose
+ *  list items can be parsed with `listItemParser`.
+ * @function
+ */
+export default function (containingType: ProductionType, listItemParser: Parser): Parser;
+//# sourceMappingURL=periodDelimitedList.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"periodDelimitedList.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/periodDelimitedList.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AACtC,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAItD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,OAAO,WACZ,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,MAAM,GACrB,MAAM,CAMR"}

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

@@ -0,0 +1,34 @@
+import Parser from '../../Parser.mjs';
+import ProductionType from '../../ProductionType.mjs';
+import literal from './literal.mjs';
+import whitespaceTolerantList from './whitespaceTolerantList.mjs';
+/**
+ * @summary Produce a parser that will parse a period-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`
+ * - An optional whitespace
+ * - A period
+ * - An optional 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 or periods.
+ *
+ * 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 period-delimited list, whose
+ *  list items can be parsed with `listItemParser`.
+ * @function
+ */
+export default function (containingType, listItemParser) {
+    return whitespaceTolerantList(containingType, listItemParser, literal(ProductionType.period));
+}
+//# sourceMappingURL=periodDelimitedList.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"periodDelimitedList.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/periodDelimitedList.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AACtC,OAAO,cAAc,MAAM,0BAA0B,CAAC;AACtD,OAAO,OAAO,MAAM,eAAe,CAAC;AACpC,OAAO,sBAAsB,MAAM,8BAA8B,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,OAAO,WACZ,cAA8B,EAC9B,cAAsB;IAEtB,OAAO,sBAAsB,CAC3B,cAAc,EACd,cAAc,EACd,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAC/B,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,12 @@
+import Parser from '../../Parser.mjs';
+/**
+ * @summary Generate a parser that may be defined in terms of itself.
+ * @description
+ * This is to prevent issues with looping / self-referential definitions.
+ * @param parserGetter A callback that returns a `Parser`.
+ * @returns {Parser} A `Parser` that, only upon execution, will resolve the
+ *  constituent parsers that compose its definition.
+ * @function
+ */
+export default function (parserGetter: () => Parser): Parser;
+//# sourceMappingURL=recursiveParser.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recursiveParser.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/recursiveParser.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAGtC;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,WAAW,YAAY,EAAE,MAAM,MAAM,GAAG,MAAM,CAK3D"}

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

@@ -0,0 +1,14 @@
+import Parser from '../../Parser.mjs';
+/**
+ * @summary Generate a parser that may be defined in terms of itself.
+ * @description
+ * This is to prevent issues with looping / self-referential definitions.
+ * @param parserGetter A callback that returns a `Parser`.
+ * @returns {Parser} A `Parser` that, only upon execution, will resolve the
+ *  constituent parsers that compose its definition.
+ * @function
+ */
+export default function (parserGetter) {
+    return new Parser(() => parserGetter().name(), (state) => parserGetter().execute(state));
+}
+//# sourceMappingURL=recursiveParser.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recursiveParser.mjs","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/recursiveParser.mts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAGtC;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,WAAW,YAA0B;IACjD,OAAO,IAAI,MAAM,CACf,GAAG,EAAE,CAAC,YAAY,EAAE,CAAC,IAAI,EAAE,EAC3B,CAAC,KAAmB,EAAgB,EAAE,CAAC,YAAY,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CACrE,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,21 @@
+import Parser from '../../Parser.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: ProductionType, ...parserSets: Parser[][]): Parser;
+//# sourceMappingURL=recyclingSequenceOf.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recyclingSequenceOf.d.mts","sourceRoot":"","sources":["../../../../src/lib/parsers/generic/recyclingSequenceOf.mts"],"names":[],"mappings":"AACA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAGtC,OAAO,cAAc,MAAM,0BAA0B,CAAC;AAEtD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,OAAO,WACZ,cAAc,EAAE,cAAc,EAC9B,GAAG,UAAU,EAAE,MAAM,EAAE,EAAE,GACxB,MAAM,CA2CR"}