@futpib/parser 1.0.1 → 1.0.3

package/build/parserContext.js

@@ -1,7 +1,7 @@
 /* eslint-disable prefer-arrow-callback */
-import invariant from 'invariant';
-import { ParserUnexpectedEndOfInputError, ParserParsingInvariantError, ParserParsingJoinNoneError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinFurthestError, } from './parserError.js';
 import { customInvariant } from './customInvariant.js';
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+import { formatLazyMessage, isLazyMessageError } from './lazyMessageError.js';
 let parserContextId = 0;
 export class ParserContextImplementation {
     _parserInputCompanion;
@@ -33,12 +33,27 @@ export class ParserContextImplementation {
     from(elements) {
         return this._parserInputCompanion.from(elements);
     }
+    concat(sequences) {
+        return this._parserInputCompanion.concat(sequences);
+    }
     length(sequence) {
         return this._parserInputCompanion.length(sequence);
     }
     at(sequence, index) {
         return this._parserInputCompanion.at(sequence, index);
     }
+    subsequence(sequence, start, end) {
+        return this._parserInputCompanion.subsequence(sequence, start, end);
+    }
+    indexOf(sequence, element, fromIndex) {
+        return this._parserInputCompanion.indexOf(sequence, element, fromIndex);
+    }
+    indexOfSubsequence(sequence, subsequence, fromIndex) {
+        return this._parserInputCompanion.indexOfSubsequence(sequence, subsequence, fromIndex);
+    }
+    equals(sequenceA, sequenceB) {
+        return this._parserInputCompanion.equals(sequenceA, sequenceB);
+    }
     get position() {
         return this._inputReader.position;
     }
@@ -49,24 +64,41 @@ export class ParserContextImplementation {
         }
         return this._inputReader.peek(offset);
     }
+    async peekSequence(start, end) {
+        if (this._options.sliceEnd !== undefined
+            && (this.position + end - 1) >= this._options.sliceEnd) {
+            return undefined;
+        }
+        parserImplementationInvariant(start >= 0, 'start (%s) >= 0', start);
+        parserImplementationInvariant(end >= start, 'end (%s) >= start (%s)', start, end);
+        parserImplementationInvariant(Number.isSafeInteger(start), 'start (%d) is not a safe integer', start);
+        parserImplementationInvariant(Number.isSafeInteger(end), 'end (%d) is not a safe integer', end);
+        return this._inputReader.peekSequence(start, end);
+    }
     skip(offset) {
         this._inputReader.skip(offset);
     }
     async read(offset) {
         const element = await this.peek(offset);
         if (element === undefined) {
-            throw new ParserUnexpectedEndOfInputError('', this._depth, this.position);
+            throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position);
         }
         this.skip(offset + 1);
         return element;
     }
+    async readSequence(start, end) {
+        const sequence = await this.peekSequence(start, end);
+        if (sequence === undefined) {
+            throw new this._options.errorsModule.ParserUnexpectedEndOfInputError('', this._depth, this.position);
+        }
+        this.skip(end);
+        return sequence;
+    }
     lookahead(options = {}) {
         const lookaheadInputReader = this._inputReader.lookahead();
-        if (this.position !== lookaheadInputReader.position) {
-            debugger;
-        }
-        invariant(this.position === lookaheadInputReader.position, 'lookahead this.position (%s) === lookaheadInputReader.position (%s)', this.position, lookaheadInputReader.position);
-        const lookaheadParserContext = new ParserContextImplementation(this._parserInputCompanion, lookaheadInputReader, this, {
+        parserImplementationInvariant(this.position === lookaheadInputReader.position, 'lookahead this.position (%s) === lookaheadInputReader.position (%s)', this.position, lookaheadInputReader.position);
+        const ParserContext = this._options.parserContextClass ?? ParserContextImplementation;
+        const lookaheadParserContext = new ParserContext(this._parserInputCompanion, lookaheadInputReader, this, {
             ...this._options,
             ...options,
             debugName: [
@@ -78,60 +110,57 @@ export class ParserContextImplementation {
                 options.debugName,
             ].join(''),
         });
-        if (this.position !== lookaheadParserContext.position) {
-            debugger;
-        }
-        invariant(this.position === lookaheadParserContext.position, 'lookahead this.position (%s) === lookaheadParserContext.position (%s)', this.position, lookaheadParserContext.position);
+        parserImplementationInvariant(this.position === lookaheadParserContext.position, 'lookahead this.position (%s) === lookaheadParserContext.position (%s)', this.position, lookaheadParserContext.position);
         return lookaheadParserContext;
     }
     unlookahead() {
-        invariant(this._parentParserContext !== undefined, 'this._parentParserContext !== undefined');
-        invariant((this._parentParserContext._exclusiveChildParserContext === undefined
-            || this._parentParserContext._exclusiveChildParserContext === this), [
+        const parentParserContext = parserImplementationInvariant(this._parentParserContext, 'this._parentParserContext !== undefined');
+        parserImplementationInvariant((parentParserContext._exclusiveChildParserContext === undefined
+            || parentParserContext._exclusiveChildParserContext === this), [
             'Parent\'s exclusive child must be undefined or this',
             'this: %s',
             'parent: %s',
             'parent.exclusiveChild: %s',
-        ].join('\n'), this.toString(), this._parentParserContext.toString(), this._parentParserContext._exclusiveChildParserContext?.toString());
-        invariant(this._parentParserContext.position <= this.position, 'unlookahead this._parentParserContext.position (%s) <= this.position (%s)', this._parentParserContext.position, this.position);
-        const offset = this._inputReader.position - this._parentParserContext._inputReader.position;
-        this._parentParserContext.skip(offset);
-        invariant(this._parentParserContext.position === this.position, 'unlookahead this._parentParserContext.position (%s) === this.position (%s)', this._parentParserContext.position, this.position);
-        this._inputReader = this._parentParserContext._inputReader;
-        this._parentParserContext._exclusiveChildParserContext = this;
+        ], () => this.toString(), () => parentParserContext.toString(), () => parentParserContext._exclusiveChildParserContext?.toString());
+        parserImplementationInvariant(parentParserContext.position <= this.position, 'unlookahead this._parentParserContext.position (%s) <= this.position (%s)', parentParserContext.position, this.position);
+        const offset = this._inputReader.position - parentParserContext._inputReader.position;
+        parentParserContext.skip(offset);
+        parserImplementationInvariant(parentParserContext.position === this.position, 'unlookahead this._parentParserContext.position (%s) === this.position (%s)', parentParserContext.position, this.position);
+        this._inputReader = parentParserContext._inputReader;
+        parentParserContext._exclusiveChildParserContext = this;
         if (this._exclusiveChildParserContext) {
             this._exclusiveChildParserContext.unlookahead();
         }
     }
     dispose() {
-        invariant(this._parentParserContext !== undefined, 'this._parentParserContext !== undefined');
-        invariant((this._parentParserContext._exclusiveChildParserContext === undefined
-            || this._parentParserContext._exclusiveChildParserContext === this), [
+        const parentParserContext = parserImplementationInvariant(this._parentParserContext, 'this._parentParserContext !== undefined');
+        parserImplementationInvariant((parentParserContext._exclusiveChildParserContext === undefined
+            || parentParserContext._exclusiveChildParserContext === this), [
             'Parent\'s exclusive child must be undefined or this',
             'this: %s',
             'parent: %s',
             'parent.exclusiveChild: %s',
-        ].join('\n'), this.toString(), this._parentParserContext.toString(), this._parentParserContext._exclusiveChildParserContext?.toString());
-        this._parentParserContext._exclusiveChildParserContext = undefined;
+        ], () => this.toString(), () => parentParserContext.toString(), () => parentParserContext._exclusiveChildParserContext?.toString());
+        parentParserContext._exclusiveChildParserContext = undefined;
         this._parentParserContext = undefined;
     }
     invariant(value, format, ...formatArguments) {
         const parserContext = this;
-        return customInvariant(function (message) {
-            return new ParserParsingInvariantError(message, parserContext._depth, parserContext.position);
+        return customInvariant(function (lazyMessage) {
+            return new parserContext._options.errorsModule.ParserParsingInvariantError(lazyMessage, parserContext._depth, parserContext.position);
         }, value, format, ...formatArguments);
     }
     invariantJoin(value, childErrors, format, ...formatArguments) {
-        invariant(childErrors.length > 0, 'childErrors.length > 0');
+        parserImplementationInvariant(childErrors.length > 0, 'childErrors.length > 0');
         const errorJoinMode = this._options.errorJoinMode ?? 'none';
         const parserContext = this;
         if (errorJoinMode === 'none') {
-            return customInvariant(function (message) {
-                return new ParserParsingJoinNoneError(message, parserContext._depth, parserContext.position);
+            return customInvariant(function (lazyMessage) {
+                return new parserContext._options.errorsModule.ParserParsingJoinNoneError(lazyMessage, parserContext._depth, parserContext.position);
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'furthest') {
-            return customInvariant(function (message) {
+            return customInvariant(function (userLazyMessage) {
                 let furthestPosition = 0;
                 let furthestChildErrors = [];
                 for (const childError of childErrors) {
@@ -145,20 +174,31 @@ export class ParserContextImplementation {
                     }
                     furthestChildErrors.push(childError);
                 }
-                message += [
-                    '',
-                    'Furthest child error stacks, indented:',
-                    ...furthestChildErrors.flatMap(furthestChildError => furthestChildError.stack?.split('\n').map(line => '  ' + line)),
-                    'End of furthest child error stacks',
-                ].join('\n');
-                return new ParserParsingJoinFurthestError(message, parserContext._depth, furthestPosition, furthestChildErrors);
+                return new parserContext._options.errorsModule.ParserParsingJoinFurthestError([
+                    [
+                        '%s',
+                        'Furthest child error stacks, indented:',
+                        '%s',
+                        'End of furthest child error stacks',
+                    ],
+                    () => formatLazyMessage(userLazyMessage),
+                    () => furthestChildErrors.flatMap(furthestChildError => {
+                        if (isLazyMessageError(furthestChildError)) {
+                            furthestChildError.computeMessage();
+                        }
+                        return furthestChildError.stack?.split('\n').map(line => '  ' + line);
+                    }).join('\n'),
+                ], parserContext._depth, furthestPosition, furthestChildErrors);
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'deepest') {
-            return customInvariant(function (message) {
+            return customInvariant(function (userLazyMessage) {
                 let deepestDepth = 0;
                 let deepestChildErrors = [];
                 for (const childError of childErrors) {
+                    if (isLazyMessageError(childError)) {
+                        childError.computeMessage();
+                    }
                     if (childError.depth < deepestDepth) {
                         continue;
                     }
@@ -169,26 +209,42 @@ export class ParserContextImplementation {
                     }
                     deepestChildErrors.push(childError);
                 }
-                message += [
-                    '',
-                    'Deepest child error stacks, indented:',
-                    ...deepestChildErrors.flatMap(deepestChildError => deepestChildError.stack?.split('\n').map(line => '  ' + line)),
-                    'End of deepest child error stacks',
-                ].join('\n');
-                return new ParserParsingJoinDeepestError(message, deepestDepth, parserContext.position, deepestChildErrors);
+                return new parserContext._options.errorsModule.ParserParsingJoinDeepestError([
+                    [
+                        '%s',
+                        'Deepest child error stacks, indented:',
+                        '%s',
+                        'End of deepest child error stacks',
+                    ],
+                    () => formatLazyMessage(userLazyMessage),
+                    () => deepestChildErrors.flatMap(deepestChildError => {
+                        if (isLazyMessageError(deepestChildError)) {
+                            deepestChildError.computeMessage();
+                        }
+                        return deepestChildError.stack?.split('\n').map(line => '  ' + line);
+                    }).join('\n'),
+                ], deepestDepth, parserContext.position, deepestChildErrors);
             }, value, format, ...formatArguments);
         }
         if (errorJoinMode === 'all') {
-            return customInvariant(function (message) {
-                message += [
-                    '',
-                    'Child error stacks, indented:',
-                    ...childErrors.flatMap(childError => childError.stack?.split('\n').map(line => '  ' + line)),
-                    'End of child error stacks',
-                ].join('\n');
-                return new ParserParsingJoinAllError(message, parserContext._depth, parserContext.position, childErrors);
+            return customInvariant(function (userLazyMessage) {
+                return new parserContext._options.errorsModule.ParserParsingJoinAllError([
+                    [
+                        '%s',
+                        'All child error stacks, indented:',
+                        '%s',
+                        'End of all child error stacks',
+                    ],
+                    () => formatLazyMessage(userLazyMessage),
+                    () => childErrors.flatMap(childError => {
+                        if (isLazyMessageError(childError)) {
+                            childError.computeMessage();
+                        }
+                        return childError.stack?.split('\n').map(line => '  ' + line);
+                    }).join('\n'),
+                ], parserContext._depth, parserContext.position, childErrors);
             }, value, format, ...formatArguments);
         }
-        invariant(false, 'Unsupported errorJoinMode: %s', errorJoinMode);
+        return parserImplementationInvariant(false, 'Unsupported errorJoinMode: %s', errorJoinMode);
     }
 }

package/build/parserContext.test.js

@@ -2,12 +2,14 @@ import test from 'ava';
 import { ParserContextImplementation } from './parserContext.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { InputReaderImplementation } from './inputReader.js';
-import { ParserUnexpectedEndOfInputError } from './parserError.js';
+import { noStackCaptureOverheadParserErrorModule } from './parserError.js';
 const commonParserContextArguments = [
     undefined,
     {
         debugName: 'root',
         errorJoinMode: 'all',
+        errorStack: false,
+        errorsModule: noStackCaptureOverheadParserErrorModule,
     },
 ];
 test('parserContext.read', async (t) => {
@@ -22,7 +24,29 @@ test('parserContext.read', async (t) => {
     t.is(await parserContext.read(0), 'b');
     t.is(await parserContext.read(5), 'h');
     await t.throwsAsync(async () => parserContext.read(0), {
-        instanceOf: ParserUnexpectedEndOfInputError,
+        any: true,
+        name: 'ParserUnexpectedEndOfInputError',
+    });
+});
+test('parserContext.readSequence', async (t) => {
+    const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {
+        yield '';
+        yield 'abc';
+        yield 'def';
+        yield '';
+        yield 'gh';
+    })()), ...commonParserContextArguments);
+    t.is(await parserContext.readSequence(0, 0), '');
+    t.is(await parserContext.readSequence(0, 1), 'a');
+    t.is(await parserContext.readSequence(1, 4), 'cde');
+    t.is(await parserContext.readSequence(0, 1), 'f');
+    t.is(await parserContext.readSequence(0, 0), '');
+    t.is(await parserContext.readSequence(0, 1), 'g');
+    t.is(await parserContext.readSequence(1, 1), '');
+    t.is(await parserContext.readSequence(0, 0), '');
+    await t.throwsAsync(async () => parserContext.readSequence(0, 1), {
+        any: true,
+        name: 'ParserUnexpectedEndOfInputError',
     });
 });
 test('parserContext.lookahead', async (t) => {
@@ -35,11 +59,15 @@ test('parserContext.lookahead', async (t) => {
         sliceEnd: 3,
     });
     t.is(await lookaheadContext3.peek(2), 'c');
+    t.is(await lookaheadContext3.peekSequence(2, 3), 'c');
     t.is(await lookaheadContext3.peek(3), undefined);
+    t.is(await lookaheadContext3.peekSequence(3, 4), undefined);
     t.is(await lookaheadContext3.read(0), 'a');
     t.is(await lookaheadContext3.read(0), 'b');
     t.is(await lookaheadContext3.read(0), 'c');
     t.is(await lookaheadContext3.peek(0), undefined);
+    t.is(await lookaheadContext3.peekSequence(0, 1), undefined);
+    t.is(await lookaheadContext3.peekSequence(0, 0), '');
     t.is(await parserContext.peek(0), 'a');
     t.is(await lookaheadContext1.peek(0), 'a');
     t.is(await lookaheadContext2.peek(0), 'a');
@@ -52,6 +80,9 @@ test('parserContext.lookahead', async (t) => {
     t.is(lookaheadContext1.position, 1);
     t.is(lookaheadContext2.position, 0);
     t.is(lookaheadContext3.position, 3);
+    lookaheadContext3.skip(1);
+    t.is(await lookaheadContext3.peekSequence(0, 0), undefined);
+    t.is(lookaheadContext3.position, 4);
 });
 test('parserContext.unlookahead', async (t) => {
     const parserContext = new ParserContextImplementation(stringParserInputCompanion, new InputReaderImplementation(stringParserInputCompanion, (async function* () {

package/build/parserCreatorCompose.d.ts

@@ -1,3 +1,4 @@
 import { type Parser } from './parser.js';
 import { type DeriveSequenceElement } from './sequence.js';
 export declare function parserCreatorCompose<Arguments extends unknown[], OutputA, OutputB, Sequence, Element = DeriveSequenceElement<Sequence>>(f1: (...arguments_: Arguments) => Parser<OutputA, Sequence, Element>, f2: (outputA: OutputA) => Parser<OutputB, Sequence, Element>): (...arguments_: Arguments) => Parser<OutputB, Sequence, Element>;
+export declare function parserCreatorComposeMem<Arguments extends unknown[], OutputA, OutputB, Sequence, Element = DeriveSequenceElement<Sequence>>(f1: (...arguments_: Arguments) => Parser<OutputA, Sequence, Element>, f2: (outputA: OutputA) => Parser<OutputB, Sequence, Element>): (...arguments_: Arguments) => Parser<OutputB, Sequence, Element>;

package/build/parserCreatorCompose.js

@@ -1,10 +1,16 @@
+import mem from 'mem';
 export function parserCreatorCompose(f1, f2) {
-    return (...arguments_) => {
+    const parserCreatorComposedOuter = (...arguments_) => {
         const parserA = f1(...arguments_);
-        return async (parserContext) => {
+        const parserCreatorComposedInner = async (parserContext) => {
             const outputA = await parserA(parserContext);
             const parserB = f2(outputA);
             return parserB(parserContext);
         };
+        return parserCreatorComposedInner;
     };
+    return parserCreatorComposedOuter;
+}
+export function parserCreatorComposeMem(f1, f2) {
+    return parserCreatorCompose(mem(f1), mem(f2));
 }