@futpib/parser 1.0.1 → 1.0.3

package/build/elementTerminatedSequenceArrayParser.test.js

@@ -0,0 +1,34 @@
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createElementTerminatedSequenceArrayParser } from './elementTerminatedSequenceArrayParser.js';
+testProp.serial('elementTerminatedSequenceArrayParser', [
+    fc
+        .string({
+        minLength: 1,
+    })
+        .map(string => ({
+        string,
+        terminator: string.slice(-1),
+    }))
+        .filter(({ string, terminator }) => string.split(terminator).length === 2),
+], async (t, { string, terminator }) => {
+    const elementTerminatedSequenceArrayParser = createElementTerminatedSequenceArrayParser(terminator);
+    const createTestWrapperParser = (innerParser) => async (parserContext) => {
+        const strings = await innerParser(parserContext);
+        return {
+            strings,
+            nextPeek: await parserContext.peek(0),
+            position: parserContext.position,
+        };
+    };
+    const actual = await runParser(createTestWrapperParser(elementTerminatedSequenceArrayParser), string, stringParserInputCompanion);
+    t.deepEqual(actual, {
+        strings: [string.split(terminator)[0]],
+        nextPeek: undefined,
+        position: string.length,
+    });
+}, {
+    verbose: true,
+});

package/build/elementTerminatedSequenceParser.d.ts

@@ -0,0 +1,3 @@
+import { type Parser } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
+export declare const createElementTerminatedSequenceParser: <Sequence, Element = DeriveSequenceElement<Sequence>>(terminatorElement: Element) => Parser<Sequence, Sequence, Element>;

package/build/elementTerminatedSequenceParser.js

@@ -0,0 +1,27 @@
+import { setParserName } from './parser.js';
+export const createElementTerminatedSequenceParser = (terminatorElement) => {
+    const elementTerminatedSequenceParser = async (parserContext) => {
+        let start = 0;
+        let window = 1;
+        while (true) {
+            const sequence = await parserContext.peekSequence(start, start + window);
+            if (sequence === undefined) {
+                window = Math.floor(window / 2);
+                parserContext.invariant(!(start === 0 && window === 0), 'Unexpected end of input without terminated sequence');
+                parserContext.invariant(window > 0, 'Unexpected end of input without terminator');
+                continue;
+            }
+            const terminatorIndex = parserContext.indexOf(sequence, terminatorElement);
+            if (terminatorIndex === -1) {
+                start += window;
+                window *= 2;
+                continue;
+            }
+            const sequence_ = await parserContext.readSequence(0, start + terminatorIndex);
+            parserContext.skip(1);
+            return sequence_;
+        }
+    };
+    setParserName(elementTerminatedSequenceParser, `.*?${JSON.stringify(terminatorElement)}`);
+    return elementTerminatedSequenceParser;
+};

package/build/elementTerminatedSequenceParser.test.js

@@ -0,0 +1,34 @@
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createElementTerminatedSequenceParser } from './elementTerminatedSequenceParser.js';
+testProp.serial('elementTerminatedSequenceParser', [
+    fc
+        .string({
+        minLength: 1,
+    })
+        .map(string => ({
+        string,
+        terminator: string.slice(-1),
+    }))
+        .filter(({ string, terminator }) => string.split(terminator).length === 2),
+], async (t, { string, terminator }) => {
+    const elementTerminatedSequenceParser = createElementTerminatedSequenceParser(terminator);
+    const createTestWrapperParser = (innerParser) => async (parserContext) => {
+        const string = await innerParser(parserContext);
+        return {
+            string,
+            nextPeek: await parserContext.peek(0),
+            position: parserContext.position,
+        };
+    };
+    const actual = await runParser(createTestWrapperParser(elementTerminatedSequenceParser), string, stringParserInputCompanion);
+    t.deepEqual(actual, {
+        string: string.split(terminator)[0],
+        nextPeek: undefined,
+        position: string.length,
+    });
+}, {
+    verbose: true,
+});

package/build/endOfInputParser.d.ts

@@ -1,4 +1,4 @@
 import { type Parser } from './parser.js';
 import { type DeriveSequenceElement } from './sequence.js';
 export declare const createEndOfInputParser: <Sequence, Element = DeriveSequenceElement<Sequence>>() => Parser<void, Sequence, Element>;
-export declare const endOfInputParser: Parser<void, any, any>;
+export declare const endOfInputParser: Parser<void, unknown, unknown>;

package/build/exactElementParser.js

@@ -1,6 +1,11 @@
-export const createExactElementParser = (element) => async (parserContext) => {
-    const actualElement = await parserContext.peek(0);
-    parserContext.invariant(actualElement === element, 'Expected %s, got %s', element, actualElement);
-    parserContext.skip(1);
-    return element;
+import { setParserName } from './parser.js';
+export const createExactElementParser = (element) => {
+    const exactElementParser = async (parserContext) => {
+        const actualElement = await parserContext.peek(0);
+        parserContext.invariant(actualElement === element, 'Expected %s, got %s', element, actualElement);
+        parserContext.skip(1);
+        return element;
+    };
+    setParserName(exactElementParser, `createExactElementParser(${element})`);
+    return exactElementParser;
 };

package/build/exactElementSwitchParser.d.ts

@@ -0,0 +1,3 @@
+import { Parser } from "./parser.js";
+import { DeriveSequenceElement } from "./sequence.js";
+export declare const createElementSwitchParser: <Output, Sequence, Element = DeriveSequenceElement<Sequence>>(childParsers: Map<Element, Parser<unknown, Sequence, Element>>, defaultParser?: Parser<unknown, Sequence, Element>) => Parser<Output, Sequence, Element>;

package/build/exactElementSwitchParser.js

@@ -0,0 +1,22 @@
+import invariant from "invariant";
+import { getParserName, setParserName } from "./parser.js";
+import { parserImplementationInvariant } from "./parserImplementationInvariant.js";
+export const createElementSwitchParser = (childParsers, defaultParser) => {
+    parserImplementationInvariant(childParsers.size > 0, 'Element switch parser must have at least one child parser.');
+    const elementSwitchParser = async (parserContext) => {
+        const currentElement = await parserContext.peek(0);
+        parserContext.invariant(currentElement !== undefined, 'Unexpected end of input.');
+        invariant(currentElement !== undefined, 'Unexpected end of input.');
+        const childParser = childParsers.get(currentElement) ?? defaultParser;
+        parserContext.invariant(childParser, `No child parser found for element: ${String(currentElement)}`);
+        const childParserOutput = await childParser(parserContext);
+        return childParserOutput;
+    };
+    const name = [
+        'elementSwitch(',
+        ...Array.from(childParsers.entries()).map(([element, childParser]) => `${String(element)}=>${getParserName(childParser, 'anonymousElementSwitchChild')}`),
+        defaultParser ? `|default=>${getParserName(defaultParser, 'anonymousElementSwitchDefaultChild')}` : '',
+        ')',
+    ].join('');
+    return setParserName(elementSwitchParser, name);
+};

package/build/exactSequenceParser.d.ts

@@ -1,2 +1,3 @@
 import { type Parser } from './parser.js';
-export declare const createExactSequenceParser: <Sequence>(sequence: Sequence) => Parser<Sequence, Sequence, unknown>;
+export declare const createExactSequenceNaiveParser: <Sequence>(sequence: Sequence) => Parser<Sequence, Sequence, unknown>;
+export declare const createExactSequenceParser: <Sequence>(expectedSequence: Sequence) => Parser<Sequence, Sequence, unknown>;

package/build/exactSequenceParser.js

@@ -1,6 +1,6 @@
-import { inspect } from 'node:util';
 import { setParserName } from './parser.js';
-export const createExactSequenceParser = (sequence) => {
+import { inspect } from './inspect.js';
+export const createExactSequenceNaiveParser = (sequence) => {
     const exactSequenceParser = async (parserContext) => {
         const length = parserContext.length(sequence);
         for (let index = 0; index < length; index++) {
@@ -13,3 +13,13 @@ export const createExactSequenceParser = (sequence) => {
     setParserName(exactSequenceParser, inspect(sequence));
     return exactSequenceParser;
 };
+export const createExactSequenceParser = (expectedSequence) => {
+    const exactSequenceParser = async (parserContext) => {
+        const length = parserContext.length(expectedSequence);
+        const actualSequence = await parserContext.readSequence(0, length);
+        parserContext.invariant(parserContext.equals(actualSequence, expectedSequence), 'Expected "%s", got "%s"', () => inspect(expectedSequence), () => inspect(actualSequence));
+        return expectedSequence;
+    };
+    setParserName(exactSequenceParser, inspect(expectedSequence));
+    return exactSequenceParser;
+};

package/build/fetchCid.d.ts

@@ -0,0 +1 @@
+export declare function fetchCid(cidOrPath: string): Promise<AsyncIterable<Uint8Array>>;

package/build/fetchCid.js

@@ -0,0 +1,103 @@
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import pMemoize from 'p-memoize';
+import envPaths from 'env-paths';
+const paths = envPaths('parser.futpib.github.io');
+function readableWebStreamOnFinish(readableWebStream, onFinish) {
+    const reader = readableWebStream.getReader();
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                    controller.enqueue(value);
+                }
+            }
+            finally {
+                controller.close();
+                reader.releaseLock();
+                onFinish();
+            }
+        },
+        async cancel(reason) {
+            await reader.cancel(reason);
+            onFinish();
+        },
+    });
+    return stream;
+}
+class FsCache {
+    get _basePath() {
+        return path.join(paths.cache, 'fetchCid');
+    }
+    _getKeyPath(key) {
+        return path.join(this._basePath, key.replaceAll('/', '_'));
+    }
+    async get(key) {
+        try {
+            const file = await fsPromises.open(this._getKeyPath(key), 'r');
+            const stream = file.readableWebStream();
+            const streamWithClose = readableWebStreamOnFinish(stream, () => {
+                file.close();
+            });
+            return [streamWithClose, undefined];
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    async has(key) {
+        const streams = await this.get(key);
+        try {
+            return streams !== undefined;
+        }
+        finally {
+            for (const stream of streams ?? []) {
+                await stream?.cancel();
+            }
+        }
+    }
+    async set(key, [_, value]) {
+        await fsPromises.mkdir(this._basePath, {
+            recursive: true,
+        });
+        const file = await fsPromises.open(this._getKeyPath(key), 'w');
+        try {
+            for await (const chunk of value) {
+                await file.write(chunk);
+            }
+        }
+        finally {
+            await file.close();
+        }
+    }
+    async delete(key) {
+        await fsPromises.unlink(this._getKeyPath(key));
+    }
+}
+async function reallyFetchCid(cid) {
+    const response = await fetch('https://ipfs.io/ipfs/' + cid);
+    return response.body.tee();
+}
+const cachedReallyFetchCid = pMemoize(reallyFetchCid, {
+    cache: new FsCache(),
+});
+export async function fetchCid(cidOrPath) {
+    if (cidOrPath.includes('/')) {
+        const file = await fsPromises.open(cidOrPath, 'r');
+        const stream = file.readableWebStream();
+        const streamWithClose = readableWebStreamOnFinish(stream, () => {
+            file.close();
+        });
+        return streamWithClose;
+    }
+    const [readable, unused] = await cachedReallyFetchCid(cidOrPath);
+    await unused?.cancel();
+    return readable;
+}

package/build/fetchCid.test.js

@@ -0,0 +1,16 @@
+import test from 'ava';
+import { fetchCid } from './fetchCid.js';
+const cid = 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda';
+test('fetchCid', async (t) => {
+    await Promise.all([
+        fetchCid(cid),
+        fetchCid(cid),
+        fetchCid(cid),
+    ]);
+    await Promise.all([
+        fetchCid(cid),
+        fetchCid(cid),
+        fetchCid(cid),
+    ]);
+    t.pass();
+});

package/build/fixedLengthSequenceParser.d.ts

@@ -1,2 +1,3 @@
 import { type Parser } from './parser.js';
+export declare const createFixedLengthSequenceParserNaive: <Sequence>(lengthInput: bigint | number) => Parser<Sequence, Sequence, unknown>;
 export declare const createFixedLengthSequenceParser: <Sequence>(lengthInput: bigint | number) => Parser<Sequence, Sequence, unknown>;

package/build/fixedLengthSequenceParser.js

@@ -1,6 +1,6 @@
 import { setParserName } from './parser.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-export const createFixedLengthSequenceParser = (lengthInput) => {
+export const createFixedLengthSequenceParserNaive = (lengthInput) => {
     const length = BigInt(lengthInput);
     parserImplementationInvariant(length >= 0n, 'Length must be non-negative got %s.', length);
     const fixedLengthSequenceParser = async (parserContext) => {
@@ -14,3 +14,20 @@ export const createFixedLengthSequenceParser = (lengthInput) => {
     setParserName(fixedLengthSequenceParser, `.{${length}}`);
     return fixedLengthSequenceParser;
 };
+const MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+export const createFixedLengthSequenceParser = (lengthInput) => {
+    const length = BigInt(lengthInput);
+    parserImplementationInvariant(length >= 0n, 'Length must be non-negative got %s.', length);
+    const fixedLengthSequenceParser = async (parserContext) => {
+        const safeIntegerSequences = [];
+        let remainingLength = length;
+        while (remainingLength > 0n) {
+            const safeIntegerLength = length > MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : Number(length);
+            safeIntegerSequences.push(await parserContext.readSequence(0, safeIntegerLength));
+            remainingLength -= BigInt(safeIntegerLength);
+        }
+        return parserContext.concat(safeIntegerSequences);
+    };
+    setParserName(fixedLengthSequenceParser, `.{${length}}`);
+    return fixedLengthSequenceParser;
+};

package/build/fixedLengthSequenceParser.test.js

@@ -0,0 +1,41 @@
+import test from 'ava';
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { createFixedLengthSequenceParser, createFixedLengthSequenceParserNaive } from './fixedLengthSequenceParser.js';
+import { runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { HighResolutionTotalTimer } from './highResolutionTimer.js';
+import { arbitrarilySlicedAsyncIterable } from './arbitrarilySlicedAsyncInterable.js';
+const naiveTotalTimer = new HighResolutionTotalTimer();
+const totalTimer = new HighResolutionTotalTimer();
+testProp.serial('fixedLengthSequenceParser', [
+    fc
+        .bigInt({
+        min: 1n,
+        max: 2n ** 14n,
+    })
+        .chain(length => fc.tuple(arbitrarilySlicedAsyncIterable(fc.string({
+        minLength: Number(length),
+        maxLength: Number(length) * 2,
+    })), fc.constant(length))),
+], async (t, [[_, sequence], length]) => {
+    const fixedLengthSequenceParserNaive = createFixedLengthSequenceParserNaive(length);
+    const fixedLengthSequenceParser = createFixedLengthSequenceParser(length);
+    const createTestWrapperParser = (innerParser) => async (parserContext) => {
+        const result = await innerParser(parserContext);
+        return {
+            result,
+            nextPeek: await parserContext.peek(0),
+            position: parserContext.position,
+        };
+    };
+    const { output: actualNaive } = await naiveTotalTimer.measureAsync(async () => runParserWithRemainingInput(createTestWrapperParser(fixedLengthSequenceParserNaive), sequence, stringParserInputCompanion));
+    t.true(actualNaive.result.length === Number(length));
+    const { output: actual } = await totalTimer.measureAsync(async () => runParserWithRemainingInput(createTestWrapperParser(fixedLengthSequenceParser), sequence, stringParserInputCompanion));
+    t.deepEqual(actual, actualNaive);
+}, {
+    verbose: true,
+});
+test.serial('fixedLengthSequenceParser performance', t => {
+    t.true(totalTimer.time * 10n < naiveTotalTimer.time, `Naive: ${naiveTotalTimer.time / 1000000n}ms, Optimized: ${totalTimer.time / 1000000n}ms`);
+});

package/build/hasExecutable.d.ts

@@ -0,0 +1 @@
+export declare function hasExecutable(executable: string): Promise<boolean>;

package/build/hasExecutable.js

@@ -0,0 +1,8 @@
+import { execa } from 'execa';
+export async function hasExecutable(executable) {
+    const hasExecutable = execa(executable).catch(() => false).then(() => true);
+    if (!hasExecutable) {
+        console.warn('Executable %o not found', executable);
+    }
+    return hasExecutable;
+}

package/build/highResolutionTimer.d.ts

@@ -0,0 +1,16 @@
+declare class HighResolutionSubTimer {
+    private readonly _parent;
+    private readonly _start;
+    private _ended;
+    constructor(_parent: HighResolutionTotalTimer, _start: bigint);
+    end(): void;
+}
+export declare class HighResolutionTotalTimer {
+    private _total;
+    start(): HighResolutionSubTimer;
+    add(time: bigint): void;
+    get time(): bigint;
+    measure<T>(fn: () => T): T;
+    measureAsync<T>(fn: () => Promise<T>): Promise<T>;
+}
+export {};

package/build/highResolutionTimer.js

@@ -0,0 +1,42 @@
+import process from 'node:process';
+import invariant from 'invariant';
+class HighResolutionSubTimer {
+    _parent;
+    _start;
+    _ended = false;
+    constructor(_parent, _start) {
+        this._parent = _parent;
+        this._start = _start;
+    }
+    end() {
+        invariant(!this._ended, 'Timer already ended.');
+        const end = process.hrtime.bigint();
+        const time = end - this._start;
+        this._parent.add(time);
+        this._ended = true;
+    }
+}
+export class HighResolutionTotalTimer {
+    _total = 0n;
+    start() {
+        return new HighResolutionSubTimer(this, process.hrtime.bigint());
+    }
+    add(time) {
+        this._total += time;
+    }
+    get time() {
+        return this._total;
+    }
+    measure(fn) {
+        const timer = this.start();
+        const result = fn();
+        timer.end();
+        return result;
+    }
+    async measureAsync(fn) {
+        const timer = this.start();
+        const result = await fn();
+        timer.end();
+        return result;
+    }
+}

package/build/inputReader.d.ts

@@ -1,9 +1,12 @@
 import { type ParserInputCompanion } from './parserInputCompanion.js';
+import { type InputReaderState } from './inputReaderState.js';
 export type InputReader<Sequence, Element> = {
     get position(): number;
     peek(offset: number): Promise<Element | undefined>;
+    peekSequence(start: number, end: number): Promise<Sequence | undefined>;
     skip(offset: number): void;
     lookahead(): InputReader<Sequence, Element>;
+    toInputReaderState(): InputReaderState<Sequence>;
 };
 export declare class InputReaderImplementation<Sequence, Element> implements InputReader<Sequence, Element> {
     private readonly _parserInputCompanion;
@@ -11,12 +14,20 @@ export declare class InputReaderImplementation<Sequence, Element> implements Inp
     private readonly _id;
     private _position;
     private _uncommitedSkipOffset;
+    private _inputAsyncIteratorDone;
     private readonly _promiseMutex;
     private readonly _sequenceBuffer;
     constructor(_parserInputCompanion: ParserInputCompanion<Sequence, Element>, _inputAsyncIterator: AsyncIterator<Sequence>);
     get [Symbol.toStringTag](): string;
     get position(): number;
     peek(offset: number): Promise<Element | undefined>;
+    peekSequence(start: number, end: number): Promise<Sequence | undefined>;
     skip(offset: number): void;
     lookahead(): InputReader<Sequence, Element>;
+    toInputReaderState(): {
+        consumedBufferedSequences: Sequence[];
+        unconsumedBufferedSequences: Sequence[];
+        unbufferedSequences: AsyncIterator<Sequence, any, any> | undefined;
+        position: number;
+    };
 }

package/build/inputReader.js

@@ -9,6 +9,7 @@ export class InputReaderImplementation {
     _id = inputReaderId++;
     _position = 0;
     _uncommitedSkipOffset = 0;
+    _inputAsyncIteratorDone = false;
     _promiseMutex = new PromiseMutex();
     _sequenceBuffer;
     constructor(_parserInputCompanion, _inputAsyncIterator) {
@@ -41,6 +42,7 @@ export class InputReaderImplementation {
                 }
                 const inputIteratorResult = await this._inputAsyncIterator.next();
                 if (inputIteratorResult.done) {
+                    this._inputAsyncIteratorDone = true;
                     return undefined;
                 }
                 parserImplementationInvariant(this._parserInputCompanion.is(inputIteratorResult.value), [
@@ -52,6 +54,23 @@ export class InputReaderImplementation {
             }
         });
     }
+    async peekSequence(start, end) {
+        parserImplementationInvariant(start >= 0, 'start (%s) >= 0', start);
+        parserImplementationInvariant(end >= start, 'end (%s) >= start (%s)', start, end);
+        parserImplementationInvariant(Number.isSafeInteger(start), 'start (%s) is not a safe integer', start);
+        parserImplementationInvariant(Number.isSafeInteger(end), 'end (%s) is not a safe integer', end);
+        start += this._uncommitedSkipOffset;
+        end += this._uncommitedSkipOffset;
+        const sequence = this._sequenceBuffer.peekSequence(start, end);
+        if (sequence !== undefined) {
+            return sequence;
+        }
+        const lastElement = await this.peek(Math.max(0, end - 1));
+        if (lastElement === undefined) {
+            return undefined;
+        }
+        return this._sequenceBuffer.peekSequence(start, end);
+    }
     skip(offset) {
         parserImplementationInvariant(offset >= 0, 'offset >= 0');
         this._position += offset;
@@ -66,6 +85,15 @@ export class InputReaderImplementation {
     lookahead() {
         return new InputReaderLookaheadImplementation(this);
     }
+    toInputReaderState() {
+        const { consumedBufferedSequences, unconsumedBufferedSequences, } = this._sequenceBuffer.toSequenceBufferState();
+        return {
+            consumedBufferedSequences,
+            unconsumedBufferedSequences,
+            unbufferedSequences: this._inputAsyncIteratorDone ? undefined : this._inputAsyncIterator,
+            position: this._position,
+        };
+    }
 }
 class InputReaderLookaheadImplementation {
     _inputReader;
@@ -91,6 +119,12 @@ class InputReaderLookaheadImplementation {
         this._offset -= inputReaderMovedForward;
         return this._inputReader.peek(this._offset + offset);
     }
+    async peekSequence(start, end) {
+        const inputReaderMovedForward = this._inputReader.position - this._initialInputReaderPosition;
+        this._initialInputReaderPosition = this._inputReader.position;
+        this._offset -= inputReaderMovedForward;
+        return this._inputReader.peekSequence(this._offset + start, this._offset + end);
+    }
     skip(offset) {
         parserImplementationInvariant(offset >= 0, 'offset >= 0');
         this._offset += offset;
@@ -102,4 +136,7 @@ class InputReaderLookaheadImplementation {
         invariant(this.position === lookahead.position, 'this.position (%s) === lookahead.position (%s)', this.position, lookahead.position);
         return lookahead;
     }
+    toInputReaderState() {
+        return invariant(false, 'Not implemented');
+    }
 }