@futpib/parser 1.0.0 → 1.0.2

package/build/dalvikExecutableParser.test.js

@@ -0,0 +1,70 @@
+import test from 'ava';
+import { runParser } from './parser.js';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { dalvikExecutableParser, dalvikExecutableWithRawInstructionsParser } from './dalvikExecutableParser.js';
+import { fetchCid } from './fetchCid.js';
+for (const [dexCid, shouldSnapshot] of [
+    ['bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true],
+    ['bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false],
+    ['bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false],
+    ['bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false],
+]) {
+    test.serial('dex (with instructions as bytes) ' + dexCid, async (t) => {
+        const dexStream = await fetchCid(dexCid);
+        const actual = await runParser(dalvikExecutableWithRawInstructionsParser, dexStream, uint8ArrayParserInputCompanion, {
+            errorJoinMode: 'all',
+        });
+        if (shouldSnapshot) {
+            t.snapshot(actual);
+        }
+        else {
+            //console.dir(actual, { depth: null });
+            t.pass();
+        }
+    });
+}
+function objectWalk(object, f, initialPath = []) {
+    f(initialPath, object);
+    if (!object
+        || typeof object !== 'object') {
+        return;
+    }
+    if (Array.isArray(object)) {
+        for (const [index, value] of object.entries()) {
+            objectWalk(value, f, [...initialPath, index]);
+        }
+    }
+    else {
+        for (const [key, value] of Object.entries(object)) {
+            objectWalk(value, f, [...initialPath, key]);
+        }
+    }
+}
+for (const [dexCid, shouldSnapshot] of [
+    ['bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', true],
+    // [ 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', false ],
+    // [ 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', false ],
+    // [ 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false ],
+]) {
+    test.serial('dex (with parsed instructions) ' + dexCid, async (t) => {
+        const dexStream = await fetchCid(dexCid);
+        const actual = await runParser(dalvikExecutableParser, dexStream, uint8ArrayParserInputCompanion, {
+            errorJoinMode: 'all',
+        });
+        objectWalk(actual, (path) => {
+            const key = path.at(-1);
+            if (typeof key !== 'string') {
+                return;
+            }
+            t.false(key.endsWith('Offset'), 'All offsets should be resolved: ' + path.join('.'));
+            t.false(key.endsWith('Index'), 'All indexes should be resolved: ' + path.join('.'));
+        });
+        if (shouldSnapshot) {
+            t.snapshot(actual);
+        }
+        else {
+            //console.dir(actual, { depth: null });
+            t.pass();
+        }
+    });
+}

package/build/dalvikExecutableParserAgainstSmaliParser.test.js

@@ -0,0 +1,298 @@
+import test from 'ava';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion, uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { dalvikExecutableParser } from './dalvikExecutableParser.js';
+import { fetchCid } from './fetchCid.js';
+import { hasExecutable } from './hasExecutable.js';
+import { baksmaliClass } from './backsmali.js';
+import { smaliParser } from './smaliParser.js';
+import { smaliClass } from './smali.js';
+const hasBaksmaliPromise = hasExecutable('baksmali');
+const hasSmaliPromise = hasExecutable('smali');
+function objectWalk(object, f, initialPath = []) {
+    f(initialPath, object);
+    if (!object
+        || typeof object !== 'object') {
+        return;
+    }
+    if (Array.isArray(object)) {
+        for (const [index, value] of object.entries()) {
+            objectWalk(value, f, [...initialPath, index]);
+        }
+    }
+    else {
+        for (const [key, value] of Object.entries(object)) {
+            objectWalk(value, f, [...initialPath, key]);
+        }
+    }
+}
+for (const [dexCid, smaliFilePaths] of [
+    [
+        'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4',
+        [
+            'pl/czak/minimal/MainActivity',
+        ],
+    ],
+    // [
+    // 	'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq',
+    // 	[
+    // 		'd/m',
+    // 	],
+    // ],
+    // [ 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq' ],
+    // [
+    // 	'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy',
+    // 	[
+    // 		'com/journeyapps/barcodescanner/CaptureActivity',
+    // 	],
+    // ],
+    // [ 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda' ],
+]) {
+    for (const smaliFilePath of smaliFilePaths) {
+        test.serial('parse(dex) against parse(smali(dex))' + dexCid + ' ' + smaliFilePath, async (t) => {
+            const hasBaksmali = await hasBaksmaliPromise;
+            if (!hasBaksmali) {
+                t.pass('skipping test because baksmali is not available');
+                return;
+            }
+            const dexStream = await fetchCid(dexCid);
+            const smali = await baksmaliClass(dexStream, smaliFilePath);
+            const classDefinitionFromSmali = await runParser(smaliParser, smali, stringParserInputCompanion, {
+                errorJoinMode: 'all',
+            });
+            const dexStream2 = await fetchCid(dexCid);
+            const executableFromDex = await runParser(dalvikExecutableParser, dexStream2, uint8ArrayParserInputCompanion, {
+                errorJoinMode: 'all',
+            });
+            const classDefinitionFromDex = executableFromDex.classDefinitions.find(classDefinition => classDefinition.class === classDefinitionFromSmali.class);
+            // console.log(smali);
+            // console.dir({
+            // 	classDefinitionFromDex,
+            // 	classDefinitionFromSmali,
+            // }, {
+            // 	depth: null,
+            // });
+            objectWalk(classDefinitionFromDex, (_path, value) => {
+                if (value
+                    && typeof value === 'object'
+                    && 'debugInfo' in value) {
+                    value.debugInfo = undefined;
+                }
+            });
+            t.deepEqual(classDefinitionFromDex, classDefinitionFromSmali);
+        });
+    }
+}
+const smali = `
+.class public Lcom/journeyapps/barcodescanner/CaptureActivity;
+.super Landroid/app/Activity;
+.source "CaptureActivity.java"
+
+
+# instance fields
+.field private barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
+
+.field private capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+
+# direct methods
+.method public constructor <init>()V
+    .registers 1
+
+    .line 13
+    invoke-direct {p0}, Landroid/app/Activity;-><init>()V
+
+    return-void
+.end method
+
+
+# virtual methods
+.method protected initializeContent()Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
+    .registers 2
+
+    sget v0, Lcom/google/zxing/client/android/R$layout;->zxing_capture:I
+
+    .line 34
+    invoke-virtual {p0, v0}, Landroid/app/Activity;->setContentView(I)V
+
+    sget v0, Lcom/google/zxing/client/android/R$id;->zxing_barcode_scanner:I
+
+    .line 35
+    invoke-virtual {p0, v0}, Landroid/app/Activity;->findViewById(I)Landroid/view/View;
+
+    move-result-object v0
+
+    check-cast v0, Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
+
+    return-object v0
+.end method
+
+.method protected onCreate(Landroid/os/Bundle;)V
+    .registers 4
+
+    .line 19
+    invoke-super {p0, p1}, Landroid/app/Activity;->onCreate(Landroid/os/Bundle;)V
+
+    .line 21
+    invoke-virtual {p0}, Lcom/journeyapps/barcodescanner/CaptureActivity;->initializeContent()Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
+
+    move-result-object v0
+
+    iput-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
+
+    .line 23
+    new-instance v0, Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    iget-object v1, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
+
+    invoke-direct {v0, p0, v1}, Lcom/journeyapps/barcodescanner/CaptureManager;-><init>(Landroid/app/Activity;Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;)V
+
+    iput-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    .line 24
+    invoke-virtual {p0}, Landroid/app/Activity;->getIntent()Landroid/content/Intent;
+
+    move-result-object v1
+
+    invoke-virtual {v0, v1, p1}, Lcom/journeyapps/barcodescanner/CaptureManager;->initializeFromIntent(Landroid/content/Intent;Landroid/os/Bundle;)V
+
+    iget-object p1, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    .line 25
+    invoke-virtual {p1}, Lcom/journeyapps/barcodescanner/CaptureManager;->decode()V
+
+    return-void
+.end method
+
+.method protected onDestroy()V
+    .registers 2
+
+    .line 52
+    invoke-super {p0}, Landroid/app/Activity;->onDestroy()V
+
+    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    .line 53
+    invoke-virtual {v0}, Lcom/journeyapps/barcodescanner/CaptureManager;->onDestroy()V
+
+    return-void
+.end method
+
+.method public onKeyDown(ILandroid/view/KeyEvent;)Z
+    .registers 4
+
+    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;
+
+    .line 69
+    invoke-virtual {v0, p1, p2}, Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;->onKeyDown(ILandroid/view/KeyEvent;)Z
+
+    move-result v0
+
+    if-nez v0, :cond_11
+
+    invoke-super {p0, p1, p2}, Landroid/app/Activity;->onKeyDown(ILandroid/view/KeyEvent;)Z
+
+    move-result p1
+
+    if-eqz p1, :cond_f
+
+    goto :goto_11
+
+    :cond_f
+    const/4 p1, 0x0
+
+    goto :goto_12
+
+    :cond_11
+    :goto_11
+    const/4 p1, 0x1
+
+    :goto_12
+    return p1
+.end method
+
+.method protected onPause()V
+    .registers 2
+
+    .line 46
+    invoke-super {p0}, Landroid/app/Activity;->onPause()V
+
+    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    .line 47
+    invoke-virtual {v0}, Lcom/journeyapps/barcodescanner/CaptureManager;->onPause()V
+
+    return-void
+.end method
+
+.method public onRequestPermissionsResult(I[Ljava/lang/String;[I)V
+    .registers 5
+
+    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    .line 64
+    invoke-virtual {v0, p1, p2, p3}, Lcom/journeyapps/barcodescanner/CaptureManager;->onRequestPermissionsResult(I[Ljava/lang/String;[I)V
+
+    return-void
+.end method
+
+.method protected onResume()V
+    .registers 2
+
+    .line 40
+    invoke-super {p0}, Landroid/app/Activity;->onResume()V
+
+    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    .line 41
+    invoke-virtual {v0}, Lcom/journeyapps/barcodescanner/CaptureManager;->onResume()V
+
+    return-void
+.end method
+
+.method protected onSaveInstanceState(Landroid/os/Bundle;)V
+    .registers 3
+
+    .line 58
+    invoke-super {p0, p1}, Landroid/app/Activity;->onSaveInstanceState(Landroid/os/Bundle;)V
+
+    iget-object v0, p0, Lcom/journeyapps/barcodescanner/CaptureActivity;->capture:Lcom/journeyapps/barcodescanner/CaptureManager;
+
+    .line 59
+    invoke-virtual {v0, p1}, Lcom/journeyapps/barcodescanner/CaptureManager;->onSaveInstanceState(Landroid/os/Bundle;)V
+
+    return-void
+.end method
+`;
+test.serial.skip('parse(dex(smali)) againts parse(smali)', async (t) => {
+    const hasSmali = await hasSmaliPromise;
+    if (!hasSmali) {
+        t.pass('skipping test because smali is not available');
+        return;
+    }
+    const dexBuffer = await smaliClass(async function* () {
+        yield smali;
+    }());
+    const classDefinitionFromSmali = await runParser(smaliParser, smali, stringParserInputCompanion, {
+        errorJoinMode: 'all',
+    });
+    const executableFromDex = await runParser(dalvikExecutableParser, dexBuffer, uint8ArrayParserInputCompanion, {
+        errorJoinMode: 'all',
+    });
+    const classDefinitionFromDex = executableFromDex.classDefinitions.find(classDefinition => classDefinition.class === classDefinitionFromSmali.class);
+    // console.log(smali);
+    console.dir({
+        classDefinitionFromDex,
+        classDefinitionFromSmali,
+    }, {
+        depth: null,
+    });
+    objectWalk(classDefinitionFromDex, (_path, value) => {
+        if (value
+            && typeof value === 'object'
+            && 'debugInfo' in value) {
+            value.debugInfo = undefined;
+        }
+    });
+    t.deepEqual(classDefinitionFromDex, classDefinitionFromSmali);
+});

package/build/debugLogInputParser.d.ts

@@ -0,0 +1,4 @@
+import { type Parser } from './parser.js';
+export declare const createDebugLogInputParser: <Sequence>({ maxLookahead, }?: {
+    maxLookahead?: number;
+}) => Parser<void, Sequence>;

package/build/debugLogInputParser.js

@@ -0,0 +1,16 @@
+export const createDebugLogInputParser = ({ maxLookahead = 8, } = {}) => async (parserContext) => {
+    let lookahead = maxLookahead;
+    while (lookahead > 0) {
+        const sequence = await parserContext.peekSequence(0, lookahead);
+        if (!sequence) {
+            lookahead = lookahead - 1;
+            continue;
+        }
+        let prettySequence = sequence;
+        if (prettySequence instanceof Uint8Array) {
+            prettySequence = Buffer.from(prettySequence).toString('hex');
+        }
+        console.log('debugLogInput (position: %s): %s', parserContext.position, prettySequence);
+        break;
+    }
+};

package/build/debugLogParser.d.ts

@@ -1,2 +1,2 @@
-import { Parser } from "./parser.js";
+import { type Parser } from './parser.js';
 export declare const createDebugLogParser: <Output, Sequence>(childParser: Parser<Output, Sequence>) => Parser<Output, Sequence>;

package/build/debugLogParser.js

@@ -1,17 +1,28 @@
-import { getParserName, setParserName } from "./parser.js";
+import { getParserName, setParserName } from './parser.js';
 export const createDebugLogParser = (childParser) => {
     let idCounter = 0;
+    function getLogParserName() {
+        const childParserName = getParserName(childParser);
+        if (childParserName !== 'anonymous') {
+            return childParserName;
+        }
+        const debugLogParserName = getParserName(debugLogParser);
+        if (!debugLogParserName.startsWith('debugLog(')) {
+            return debugLogParserName;
+        }
+        return 'anonymousDebugLogChild';
+    }
     const debugLogParser = async (parserContext) => {
         const id = idCounter++;
         const initialPosition = parserContext.position;
-        console.debug('%s %s: started (position: %s)', getParserName(childParser), id, initialPosition);
+        console.debug('%s %s: started (position: %s)', getLogParserName(), id, initialPosition);
         try {
             const result = await childParser(parserContext);
-            console.debug('%s %s: finished (position: %s, consumed: %s): %o', getParserName(childParser), id, parserContext.position, parserContext.position - initialPosition, result);
+            console.debug('%s %s: finished (position: %s, consumed: %s): %o', getLogParserName(), id, parserContext.position, parserContext.position - initialPosition, result);
             return result;
         }
         catch (error) {
-            console.debug('%s %s: failed (position: %s, consumed: %s): %o', getParserName(childParser), id, parserContext.position, parserContext.position - initialPosition, error);
+            console.debug('%s %s: failed (position: %s, consumed: %s): %o', getLogParserName(), id, parserContext.position, parserContext.position - initialPosition, error);
             throw error;
         }
     };

package/build/disjunctionParser.d.ts

@@ -1,2 +1,3 @@
 import { type Parser } from './parser.js';
-export declare const createDisjunctionParser: <Output, Sequence>(childParsers: Array<Parser<any, Sequence, any>>) => Parser<Output, Sequence, unknown>;
+import { DeriveSequenceElement } from './sequence.js';
+export declare const createDisjunctionParser: <Output, Sequence, Element = DeriveSequenceElement<Sequence>>(childParsers: Array<Parser<any, Sequence, Element>>) => Parser<Output, Sequence, Element>;

package/build/disjunctionParser.js

@@ -1,6 +1,7 @@
 import { getParserName, setParserName } from './parser.js';
 import { ParserParsingFailedError } from './parserError.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+import { promiseSettled } from './promiseSettled.js';
 export const createDisjunctionParser = (childParsers) => {
     parserImplementationInvariant(childParsers.length > 0, 'Disjunction parser must have at least one child parser.');
     const disjunctionParser = async (parserContext) => {
@@ -9,13 +10,14 @@ export const createDisjunctionParser = (childParsers) => {
             const childParserContext = parserContext.lookahead({
                 debugName: getParserName(childParser, 'anonymousDisjunctionChild'),
             });
-            const [childParserResult] = await Promise.allSettled([childParser(childParserContext)]);
+            const childParserResult = await promiseSettled(childParser(childParserContext));
             if (childParserResult.status === 'fulfilled') {
                 const successfulParserOutput = childParserResult.value;
                 childParserContext.unlookahead();
                 childParserContext.dispose();
                 return successfulParserOutput;
             }
+            childParserContext.dispose();
             const error = childParserResult.reason;
             if (error instanceof ParserParsingFailedError) {
                 parserParsingFailedErrors.push(error);
@@ -24,7 +26,7 @@ export const createDisjunctionParser = (childParsers) => {
                 throw error;
             }
         }
-        parserContext.invariantJoin(false, parserParsingFailedErrors, 'No disjunction child parser succeeded.');
+        return parserContext.invariantJoin(false, parserParsingFailedErrors, 'No disjunction child parser succeeded.');
     };
     const name = [
         '(',

package/build/elementParser.d.ts

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

package/build/elementParser.js

@@ -1 +1 @@
-export const createElementParser = () => parserContext => parserContext.read(0);
+export const createElementParser = () => async (parserContext) => parserContext.read(0);

package/build/elementTerminatedArrayParser.d.ts

@@ -0,0 +1,3 @@
+import { Parser } from "./parser.js";
+import { DeriveSequenceElement } from "./sequence.js";
+export declare const createElementTerminatedArrayParserUnsafe: <ElementOutput, Sequence, Element = DeriveSequenceElement<Sequence>>(elementParser: Parser<ElementOutput, Sequence>, terminatorElement: Element) => Parser<ElementOutput[], Sequence>;

package/build/elementTerminatedArrayParser.js

@@ -0,0 +1,18 @@
+import { getParserName, setParserName } from "./parser.js";
+export const createElementTerminatedArrayParserUnsafe = (elementParser, terminatorElement) => {
+    const elementTerminatedArrayParserUnsafe = async (parserContext) => {
+        const elements = [];
+        while (true) {
+            const inputElement = await parserContext.peek(0);
+            if (inputElement === terminatorElement) {
+                parserContext.skip(1);
+                break;
+            }
+            const element = await elementParser(parserContext);
+            elements.push(element);
+        }
+        return elements;
+    };
+    setParserName(elementTerminatedArrayParserUnsafe, `${getParserName(elementParser, 'anonymousElement')}*?${JSON.stringify(terminatorElement)}`);
+    return elementTerminatedArrayParserUnsafe;
+};

package/build/elementTerminatedArrayParser.test.js

@@ -0,0 +1,52 @@
+import test from 'ava';
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { createTerminatedArrayParserNaive } from './terminatedArrayParser.js';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { HighResolutionTotalTimer } from './highResolutionTimer.js';
+import { createElementParser } from './elementParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createTupleParser } from './tupleParser.js';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createElementTerminatedArrayParserUnsafe } from './elementTerminatedArrayParser.js';
+const naiveTotalTimer = new HighResolutionTotalTimer();
+const elementTotalTimer = new HighResolutionTotalTimer();
+testProp.serial('elementTerminatedArrayParserUnsafe', [
+    fc
+        .string({
+        minLength: 1,
+    })
+        .map(string => ({
+        string,
+        terminator: string.slice(-1)
+    }))
+        .filter(({ string, terminator }) => string.split(terminator).length === 2)
+], async (t, { string, terminator }) => {
+    const terminatedArrayParserNaive = promiseCompose(createTerminatedArrayParserNaive(promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+        createElementParser(),
+    ]), ([_, element]) => element), createExactSequenceParser(terminator)), ([characters]) => characters);
+    const elementTerminatedArrayParserUnsafe = createElementTerminatedArrayParserUnsafe(promiseCompose(createTupleParser([
+        createNegativeLookaheadParser(createExactSequenceParser(terminator)),
+        createElementParser(),
+    ]), ([_, element]) => element), terminator);
+    const createTestWrapperParser = (innerParser) => async (parserContext) => {
+        const characters = await innerParser(parserContext);
+        return {
+            string: characters.join(''),
+            nextPeek: await parserContext.peek(0),
+            position: parserContext.position,
+        };
+    };
+    const actualNaive = await naiveTotalTimer.measureAsync(() => runParser(createTestWrapperParser(terminatedArrayParserNaive), string, stringParserInputCompanion));
+    t.is(actualNaive.string.length, string.split(terminator)[0].length);
+    const actual = await elementTotalTimer.measureAsync(() => runParser(createTestWrapperParser(elementTerminatedArrayParserUnsafe), string, stringParserInputCompanion));
+    t.deepEqual(actual, actualNaive);
+}, {
+    verbose: true,
+});
+test.serial('elementTerminatedArrayParserUnsafe performance', t => {
+    t.true(elementTotalTimer.time * 4n < naiveTotalTimer.time, `Naive: ${naiveTotalTimer.time / 1000000n}ms, Unsafe: ${elementTotalTimer.time / 1000000n}ms`);
+});

package/build/elementTerminatedSequenceArrayParser.d.ts

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

package/build/elementTerminatedSequenceArrayParser.js

@@ -0,0 +1,32 @@
+import { setParserName } from "./parser.js";
+export const createElementTerminatedSequenceArrayParser = (terminatorElement) => {
+    const elementTerminatedSequenceArrayParser = async (parserContext) => {
+        const sequences = [];
+        let start = 0;
+        let window = 1;
+        while (true) {
+            const sequence = await parserContext.peekSequence(start, start + window);
+            if (sequence === undefined) {
+                window = Math.floor(window / 2);
+                if (start === 0 && window === 0) {
+                    break;
+                }
+                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);
+            sequences.push(sequence_);
+            start = 0;
+        }
+        return sequences;
+    };
+    setParserName(elementTerminatedSequenceArrayParser, `(.*?${JSON.stringify(terminatorElement)})*`);
+    return elementTerminatedSequenceArrayParser;
+};

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 { Parser } from "./parser.js";
+import { 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;
+};