@futpib/parser 1.0.1 → 1.0.3

package/build/dalvikExecutableUnparser.d.ts

@@ -0,0 +1,4 @@
+import { type Unparser } from './unparser.js';
+import { type DalvikExecutable } from './dalvikExecutable.js';
+import { type DalvikBytecode } from './dalvikBytecodeParser.js';
+export declare const dalvikExecutableUnparser: Unparser<DalvikExecutable<DalvikBytecode>, Uint8Array>;

package/build/dalvikExecutableUnparser.js

@@ -0,0 +1,406 @@
+import { uintUnparser, ushortUnparser } from './dalvikBytecodeUnparser/formatUnparsers.js';
+import { createPoolBuilders } from './dalvikExecutableUnparser/poolBuilders.js';
+import { scanForPoolReferences } from './dalvikExecutableUnparser/poolScanners.js';
+import { createSectionUnparsers } from './dalvikExecutableUnparser/sectionUnparsers.js';
+import { createAnnotationUnparsers } from './dalvikExecutableUnparser/annotationUnparsers.js';
+import { alignmentUnparser } from './dalvikExecutableUnparser/utils.js';
+async function* yieldAndCapture(gen) {
+    let value;
+    for await (value of gen) {
+        yield value;
+    }
+    return value;
+}
+/**
+ * Helper function to write a pool size and reserve space for its offset.
+ * Returns a WriteLater for the offset.
+ */
+async function* writePoolHeader(size, unparserContext) {
+    yield* uintUnparser(size, unparserContext);
+    const offsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+    return offsetWriteLater;
+}
+/**
+ * Helper function to conditionally write an offset placeholder.
+ * Returns WriteLater if condition is true, otherwise writes 0 and returns undefined.
+ */
+async function* writeConditionalOffset(condition, unparserContext) {
+    if (condition) {
+        const offsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+        return offsetWriteLater;
+    }
+    else {
+        yield* uintUnparser(0, unparserContext);
+        return undefined;
+    }
+}
+/**
+ * Helper class to track offset and count for a section of items.
+ * Records the offset of the first item and counts items as they are written.
+ */
+class SectionTracker {
+    _offset = 0;
+    _count = 0;
+    recordItem(position) {
+        if (this._count === 0) {
+            this._offset = position;
+        }
+        this._count++;
+    }
+    get offset() {
+        return this._offset;
+    }
+    get count() {
+        return this._count;
+    }
+}
+export const dalvikExecutableUnparser = async function* (input, unparserContext) {
+    const poolBuilders = createPoolBuilders();
+    scanForPoolReferences(input, poolBuilders);
+    const sectionUnparsers = createSectionUnparsers(poolBuilders);
+    const annotationUnparsers = createAnnotationUnparsers(sectionUnparsers.getStringIndex, sectionUnparsers.getTypeIndex, sectionUnparsers.getFieldIndex, sectionUnparsers.getMethodIndex, sectionUnparsers.encodedValueUnparser);
+    const { stringPool, typePool, protoPool, fieldPool, methodPool } = poolBuilders;
+    const magicBytes = new Uint8Array([0x64, 0x65, 0x78, 0x0A]);
+    yield magicBytes;
+    const versionBytes = new Uint8Array([0x30, 0x33, 0x35, 0x00]);
+    yield versionBytes;
+    const checksumWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+    const sha1WriteLater = yield* yieldAndCapture(unparserContext.writeLater(20));
+    const fileSizeWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+    yield* uintUnparser(0x70, unparserContext);
+    yield* uintUnparser(0x12345678, unparserContext);
+    const linkData = input.link;
+    const hasLink = !!(linkData && linkData.length > 0);
+    if (hasLink) {
+        yield* uintUnparser(linkData.length, unparserContext);
+    }
+    else {
+        yield* uintUnparser(0, unparserContext);
+    }
+    const linkOffsetWriteLater = yield* writeConditionalOffset(hasLink, unparserContext);
+    const mapOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+    const stringIdsOffsetWriteLater = yield* writePoolHeader(stringPool.size(), unparserContext);
+    const typeIdsOffsetWriteLater = yield* writePoolHeader(typePool.size(), unparserContext);
+    const protoIdsOffsetWriteLater = yield* writePoolHeader(protoPool.size(), unparserContext);
+    const fieldIdsOffsetWriteLater = yield* writePoolHeader(fieldPool.size(), unparserContext);
+    const methodIdsOffsetWriteLater = yield* writePoolHeader(methodPool.size(), unparserContext);
+    const classDefsOffsetWriteLater = yield* writePoolHeader(input.classDefinitions.length, unparserContext);
+    const dataOffsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+    const dataSizeWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+    const stringIdsOffset = unparserContext.position;
+    yield* unparserContext.writeEarlier(stringIdsOffsetWriteLater, uintUnparser, stringIdsOffset);
+    const stringDataOffsetWriteLaters = [];
+    for (let i = 0; i < stringPool.size(); i++) {
+        const offsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+        stringDataOffsetWriteLaters.push(offsetWriteLater);
+    }
+    const typeIdsOffset = unparserContext.position;
+    yield* unparserContext.writeEarlier(typeIdsOffsetWriteLater, uintUnparser, typeIdsOffset);
+    for (const type of typePool.getTypes()) {
+        const stringIndex = sectionUnparsers.getStringIndex(type);
+        yield* uintUnparser(stringIndex, unparserContext);
+    }
+    const protoIdsOffset = unparserContext.position;
+    yield* unparserContext.writeEarlier(protoIdsOffsetWriteLater, uintUnparser, protoIdsOffset);
+    const protoParameterListOffsetWriteLaters = [];
+    for (const proto of protoPool.getProtos()) {
+        const shortyIndex = sectionUnparsers.getStringIndex(proto.shorty);
+        const returnTypeIndex = sectionUnparsers.getTypeIndex(proto.returnType);
+        yield* uintUnparser(shortyIndex, unparserContext);
+        yield* uintUnparser(returnTypeIndex, unparserContext);
+        if (proto.parameters.length > 0) {
+            const offsetWriteLater = yield* yieldAndCapture(unparserContext.writeLater(4));
+            protoParameterListOffsetWriteLaters.push(offsetWriteLater);
+        }
+        else {
+            protoParameterListOffsetWriteLaters.push(null);
+            yield* uintUnparser(0, unparserContext);
+        }
+    }
+    const fieldIdsOffset = unparserContext.position;
+    yield* unparserContext.writeEarlier(fieldIdsOffsetWriteLater, uintUnparser, fieldIdsOffset);
+    for (const field of fieldPool.getFields()) {
+        yield* sectionUnparsers.fieldIdUnparser(field, unparserContext);
+    }
+    const methodIdsOffset = unparserContext.position;
+    yield* unparserContext.writeEarlier(methodIdsOffsetWriteLater, uintUnparser, methodIdsOffset);
+    for (const method of methodPool.getMethods()) {
+        yield* sectionUnparsers.methodIdUnparser(method, unparserContext);
+    }
+    const classDefsOffset = unparserContext.position;
+    yield* unparserContext.writeEarlier(classDefsOffsetWriteLater, uintUnparser, classDefsOffset);
+    const classDefItems = [];
+    for (const classDef of input.classDefinitions) {
+        const classTypeIndex = sectionUnparsers.getTypeIndex(classDef.class);
+        const accessFlags = sectionUnparsers.accessFlagsToNumber(classDef.accessFlags);
+        const superclassTypeIndex = sectionUnparsers.getTypeIndex(classDef.superclass);
+        yield* uintUnparser(classTypeIndex, unparserContext);
+        yield* uintUnparser(accessFlags, unparserContext);
+        yield* uintUnparser(superclassTypeIndex, unparserContext);
+        const interfacesOffsetWriteLater = yield* writeConditionalOffset(classDef.interfaces.length > 0, unparserContext);
+        const sourceFileIndex = classDef.sourceFile ? sectionUnparsers.getStringIndex(classDef.sourceFile) : 0xFFFFFFFF;
+        yield* uintUnparser(sourceFileIndex, unparserContext);
+        const annotationsOffsetWriteLater = yield* writeConditionalOffset(!!classDef.annotations, unparserContext);
+        const hasClassData = !!(classDef.classData && (classDef.classData.staticFields.length > 0 ||
+            classDef.classData.instanceFields.length > 0 ||
+            classDef.classData.directMethods.length > 0 ||
+            classDef.classData.virtualMethods.length > 0));
+        const classDataOffsetWriteLater = yield* writeConditionalOffset(hasClassData, unparserContext);
+        const staticValuesOffsetWriteLater = yield* writeConditionalOffset(classDef.staticValues.length > 0, unparserContext);
+        classDefItems.push({
+            interfacesOffsetWriteLater,
+            annotationsOffsetWriteLater,
+            classDataOffsetWriteLater,
+            staticValuesOffsetWriteLater,
+        });
+    }
+    const dataOffset = unparserContext.position;
+    yield* unparserContext.writeEarlier(dataOffsetWriteLater, uintUnparser, dataOffset);
+    for (let i = 0; i < stringPool.size(); i++) {
+        const stringDataOffset = unparserContext.position;
+        yield* unparserContext.writeEarlier(stringDataOffsetWriteLaters[i], uintUnparser, stringDataOffset);
+        yield* sectionUnparsers.stringDataUnparser(stringPool.getStrings()[i], unparserContext);
+    }
+    const typeListItemsTracker = new SectionTracker();
+    for (let i = 0; i < protoPool.size(); i++) {
+        const proto = protoPool.getProtos()[i];
+        if (proto.parameters.length > 0) {
+            yield* alignmentUnparser(4)(undefined, unparserContext);
+            typeListItemsTracker.recordItem(unparserContext.position);
+            const paramListOffset = unparserContext.position;
+            const writeLater = protoParameterListOffsetWriteLaters[i];
+            if (writeLater) {
+                yield* unparserContext.writeEarlier(writeLater, uintUnparser, paramListOffset);
+            }
+            yield* sectionUnparsers.typeListUnparser(proto.parameters, unparserContext);
+        }
+    }
+    // Track classDataItem, codeItem, and debugInfoItem for later writing
+    // Collect data to write items grouped by type (required by DEX format)
+    const classDataToWrite = [];
+    const codeToWrite = [];
+    const debugInfoToWrite = [];
+    // First pass: collect type lists, encoded arrays, and classData/code/debugInfo to write
+    const encodedArrayItemsTracker = new SectionTracker();
+    const typeListsToWrite = [];
+    const encodedArraysToWrite = [];
+    for (let classIdx = 0; classIdx < input.classDefinitions.length; classIdx++) {
+        const classDef = input.classDefinitions[classIdx];
+        const classDefItem = classDefItems[classIdx];
+        if (classDef.interfaces.length > 0 && classDefItem.interfacesOffsetWriteLater) {
+            typeListsToWrite.push({
+                interfaces: classDef.interfaces,
+                offsetWriteLater: classDefItem.interfacesOffsetWriteLater,
+            });
+        }
+        if (classDef.staticValues.length > 0 && classDefItem.staticValuesOffsetWriteLater) {
+            encodedArraysToWrite.push({
+                staticValues: classDef.staticValues,
+                offsetWriteLater: classDefItem.staticValuesOffsetWriteLater,
+            });
+        }
+        if (classDef.classData && classDefItem.classDataOffsetWriteLater) {
+            classDataToWrite.push({ classDef, classDefItem, classIdx });
+            // Collect code items from this class
+            const allMethods = [...classDef.classData.directMethods, ...classDef.classData.virtualMethods];
+            for (const method of allMethods) {
+                if (method.code) {
+                    codeToWrite.push({ code: method.code });
+                }
+            }
+        }
+    }
+    // Second pass: write all type lists (interfaces)
+    for (const typeList of typeListsToWrite) {
+        yield* alignmentUnparser(4)(undefined, unparserContext);
+        typeListItemsTracker.recordItem(unparserContext.position);
+        const typeListOffset = unparserContext.position;
+        yield* unparserContext.writeEarlier(typeList.offsetWriteLater, uintUnparser, typeListOffset);
+        yield* sectionUnparsers.typeListUnparser(typeList.interfaces, unparserContext);
+    }
+    // Third pass: write all encoded arrays (static values)
+    for (const encodedArray of encodedArraysToWrite) {
+        encodedArrayItemsTracker.recordItem(unparserContext.position);
+        const encodedArrayOffset = unparserContext.position;
+        yield* unparserContext.writeEarlier(encodedArray.offsetWriteLater, uintUnparser, encodedArrayOffset);
+        yield* sectionUnparsers.encodedArrayUnparser(encodedArray.staticValues, unparserContext);
+    }
+    // Fourth pass: write all code items (grouped) and build offset map
+    const codeItemsTracker = new SectionTracker();
+    const codeOffsetMap = new Map();
+    for (const { code } of codeToWrite) {
+        yield* alignmentUnparser(4)(undefined, unparserContext);
+        codeItemsTracker.recordItem(unparserContext.position);
+        const codeOffset = unparserContext.position;
+        codeOffsetMap.set(code, codeOffset);
+        let debugInfoOffsetWriteLater;
+        yield* sectionUnparsers.codeItemUnparser(result => {
+            debugInfoOffsetWriteLater = result.debugInfoOffsetWriteLater;
+        })(code, unparserContext);
+        if (code.debugInfo && debugInfoOffsetWriteLater) {
+            debugInfoToWrite.push({ debugInfo: code.debugInfo, offsetWriteLater: debugInfoOffsetWriteLater });
+        }
+    }
+    // Fifth pass: write all classData items (grouped) using the offset map
+    const classDataItemsTracker = new SectionTracker();
+    for (const { classDef, classDefItem } of classDataToWrite) {
+        classDataItemsTracker.recordItem(unparserContext.position);
+        const classDataOffset = unparserContext.position;
+        if (classDefItem.classDataOffsetWriteLater && classDef.classData) {
+            yield* unparserContext.writeEarlier(classDefItem.classDataOffsetWriteLater, uintUnparser, classDataOffset);
+            yield* sectionUnparsers.classDataUnparser(codeOffsetMap)(classDef.classData, unparserContext);
+        }
+    }
+    // Sixth pass: write all debugInfo items (grouped)
+    const debugInfoItemsTracker = new SectionTracker();
+    for (const { debugInfo, offsetWriteLater } of debugInfoToWrite) {
+        debugInfoItemsTracker.recordItem(unparserContext.position);
+        const debugInfoOffset = unparserContext.position;
+        yield* unparserContext.writeEarlier(offsetWriteLater, uintUnparser, debugInfoOffset);
+        yield* sectionUnparsers.debugInfoUnparser(debugInfo, unparserContext);
+    }
+    // Seventh pass: write annotations
+    const annotationsDirectoryItemsTracker = new SectionTracker();
+    const annotationSetItemsTracker = new SectionTracker();
+    const annotationSetRefListItemsTracker = new SectionTracker();
+    const annotationItemsTracker = new SectionTracker();
+    const annotationSetsToWrite = [];
+    const annotationSetRefListsToWrite = [];
+    // First sub-pass: write annotation directories and ref lists, collect sets/items
+    for (let classIdx = 0; classIdx < input.classDefinitions.length; classIdx++) {
+        const classDef = input.classDefinitions[classIdx];
+        const classDefItem = classDefItems[classIdx];
+        if (classDef.annotations && classDefItem.annotationsOffsetWriteLater) {
+            yield* alignmentUnparser(4)(undefined, unparserContext);
+            annotationsDirectoryItemsTracker.recordItem(unparserContext.position);
+            const annotationsOffset = unparserContext.position;
+            yield* unparserContext.writeEarlier(classDefItem.annotationsOffsetWriteLater, uintUnparser, annotationsOffset);
+            const annotationOffsetWriteLaters = {};
+            yield* annotationUnparsers.annotationsDirectoryItemUnparser(annotationOffsetWriteLaters)(classDef.annotations, unparserContext);
+            if (classDef.annotations.classAnnotations.length > 0 && annotationOffsetWriteLaters.classAnnotationsOffsetWriteLater) {
+                annotationSetsToWrite.push({
+                    annotations: classDef.annotations.classAnnotations,
+                    setOffsetWriteLater: annotationOffsetWriteLaters.classAnnotationsOffsetWriteLater,
+                    itemOffsetWriteLaters: [],
+                });
+            }
+            for (let i = 0; i < classDef.annotations.fieldAnnotations.length; i++) {
+                const fieldAnnotation = classDef.annotations.fieldAnnotations[i];
+                const fieldAnnotationsOffsetWriteLater = annotationOffsetWriteLaters.fieldAnnotationsOffsetWriteLaters?.[i];
+                if (fieldAnnotation.annotations && fieldAnnotation.annotations.length > 0 && fieldAnnotationsOffsetWriteLater) {
+                    annotationSetsToWrite.push({
+                        annotations: fieldAnnotation.annotations,
+                        setOffsetWriteLater: fieldAnnotationsOffsetWriteLater,
+                        itemOffsetWriteLaters: [],
+                    });
+                }
+            }
+            for (let i = 0; i < classDef.annotations.methodAnnotations.length; i++) {
+                const methodAnnotation = classDef.annotations.methodAnnotations[i];
+                if (methodAnnotation.annotations.length > 0 && annotationOffsetWriteLaters.methodAnnotationsOffsetWriteLaters?.[i]) {
+                    annotationSetsToWrite.push({
+                        annotations: methodAnnotation.annotations,
+                        setOffsetWriteLater: annotationOffsetWriteLaters.methodAnnotationsOffsetWriteLaters[i],
+                        itemOffsetWriteLaters: [],
+                    });
+                }
+            }
+            for (let i = 0; i < classDef.annotations.parameterAnnotations.length; i++) {
+                const paramAnnotation = classDef.annotations.parameterAnnotations[i];
+                if (annotationOffsetWriteLaters.parameterAnnotationsOffsetWriteLaters?.[i]) {
+                    annotationSetRefListsToWrite.push({
+                        parameterAnnotations: paramAnnotation.annotations,
+                        refListOffsetWriteLater: annotationOffsetWriteLaters.parameterAnnotationsOffsetWriteLaters[i],
+                        setOffsetWriteLaters: [],
+                    });
+                }
+            }
+        }
+    }
+    // Second sub-pass: write all annotation set ref lists
+    for (const refList of annotationSetRefListsToWrite) {
+        yield* alignmentUnparser(4)(undefined, unparserContext);
+        annotationSetRefListItemsTracker.recordItem(unparserContext.position);
+        const refListOffset = unparserContext.position;
+        yield* unparserContext.writeEarlier(refList.refListOffsetWriteLater, uintUnparser, refListOffset);
+        yield* annotationUnparsers.annotationSetRefListUnparser(refList.setOffsetWriteLaters)(refList.parameterAnnotations, unparserContext);
+        // Collect annotation sets from this ref list
+        for (let j = 0; j < refList.parameterAnnotations.length; j++) {
+            const paramSet = refList.parameterAnnotations[j];
+            const annotationSetOffsetWriteLater = refList.setOffsetWriteLaters[j];
+            if (paramSet.length > 0 && annotationSetOffsetWriteLater) {
+                annotationSetsToWrite.push({
+                    annotations: paramSet,
+                    setOffsetWriteLater: annotationSetOffsetWriteLater,
+                    itemOffsetWriteLaters: [],
+                });
+            }
+        }
+    }
+    // Third sub-pass: write all annotation sets
+    for (const annotationSet of annotationSetsToWrite) {
+        yield* alignmentUnparser(4)(undefined, unparserContext);
+        annotationSetItemsTracker.recordItem(unparserContext.position);
+        const setOffset = unparserContext.position;
+        yield* unparserContext.writeEarlier(annotationSet.setOffsetWriteLater, uintUnparser, setOffset);
+        yield* annotationUnparsers.annotationSetItemUnparser(annotationSet.itemOffsetWriteLaters)(annotationSet.annotations, unparserContext);
+    }
+    // Fourth sub-pass: write all annotation items
+    for (const annotationSet of annotationSetsToWrite) {
+        for (let i = 0; i < annotationSet.annotations.length; i++) {
+            annotationItemsTracker.recordItem(unparserContext.position);
+            const itemOffset = unparserContext.position;
+            yield* unparserContext.writeEarlier(annotationSet.itemOffsetWriteLaters[i], uintUnparser, itemOffset);
+            yield* annotationUnparsers.annotationItemUnparser(annotationSet.annotations[i], unparserContext);
+        }
+    }
+    if (input.link && linkOffsetWriteLater) {
+        const linkOffset = unparserContext.position;
+        yield* unparserContext.writeEarlier(linkOffsetWriteLater, uintUnparser, linkOffset);
+        yield input.link;
+    }
+    yield* alignmentUnparser(4)(undefined, unparserContext);
+    const mapOffset = unparserContext.position;
+    yield* unparserContext.writeEarlier(mapOffsetWriteLater, uintUnparser, mapOffset);
+    // Build map items from section definitions
+    const sectionConfigs = [
+        { type: 0x0000, size: 1, offset: 0 },
+        { type: 0x0001, size: stringPool.size(), offset: stringIdsOffset },
+        { type: 0x0002, size: typePool.size(), offset: typeIdsOffset },
+        { type: 0x0003, size: protoPool.size(), offset: protoIdsOffset },
+        { type: 0x0004, size: fieldPool.size(), offset: fieldIdsOffset },
+        { type: 0x0005, size: methodPool.size(), offset: methodIdsOffset },
+        { type: 0x0006, size: input.classDefinitions.length, offset: classDefsOffset },
+        { type: 0x2002, size: stringPool.size(), offset: dataOffset },
+        { type: 0x1001, size: typeListItemsTracker.count, offset: typeListItemsTracker.offset },
+        { type: 0x1002, size: annotationSetRefListItemsTracker.count, offset: annotationSetRefListItemsTracker.offset },
+        { type: 0x1003, size: annotationSetItemsTracker.count, offset: annotationSetItemsTracker.offset },
+        { type: 0x2000, size: classDataItemsTracker.count, offset: classDataItemsTracker.offset },
+        { type: 0x2001, size: codeItemsTracker.count, offset: codeItemsTracker.offset },
+        { type: 0x2003, size: debugInfoItemsTracker.count, offset: debugInfoItemsTracker.offset },
+        { type: 0x2004, size: annotationItemsTracker.count, offset: annotationItemsTracker.offset },
+        { type: 0x2005, size: encodedArrayItemsTracker.count, offset: encodedArrayItemsTracker.offset },
+        { type: 0x2006, size: annotationsDirectoryItemsTracker.count, offset: annotationsDirectoryItemsTracker.offset },
+        { type: 0x1000, size: 1, offset: mapOffset },
+    ];
+    // Filter out sections with zero size (except header and map which always exist)
+    const mapItems = sectionConfigs.filter(config => config.type === 0x0000 || config.type === 0x1000 || config.size > 0);
+    // Sort map items by offset (required by DEX format spec)
+    mapItems.sort((a, b) => a.offset - b.offset);
+    yield* uintUnparser(mapItems.length, unparserContext);
+    for (const mapItem of mapItems) {
+        yield* ushortUnparser(mapItem.type, unparserContext);
+        yield* ushortUnparser(0, unparserContext);
+        yield* uintUnparser(mapItem.size, unparserContext);
+        yield* uintUnparser(mapItem.offset, unparserContext);
+    }
+    const fileSize = unparserContext.position;
+    yield* unparserContext.writeEarlier(fileSizeWriteLater, uintUnparser, fileSize);
+    const dataSize = fileSize - dataOffset;
+    yield* unparserContext.writeEarlier(dataSizeWriteLater, uintUnparser, dataSize);
+    yield* unparserContext.writeEarlier(checksumWriteLater, uintUnparser, 0);
+    const zeroSha1 = new Uint8Array(20);
+    yield* unparserContext.writeEarlier(sha1WriteLater, async function* (hash) {
+        yield hash;
+    }, zeroSha1);
+};

package/build/dalvikExecutableUnparser.test.js

@@ -0,0 +1,31 @@
+import { testProp } from '@fast-check/ava';
+import * as fc from 'fast-check';
+import { createArbitraryDalvikExecutable } from './arbitraryDalvikExecutable.js';
+import { dalvikExecutableUnparser } from './dalvikExecutableUnparser.js';
+import { dalvikExecutableParser } from './dalvikExecutableParser.js';
+import { runParser } from './parser.js';
+import { runUnparser } from './unparser.js';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import { uint8ArrayUnparserOutputCompanion } from './unparserOutputCompanion.js';
+import { uint8ArrayAsyncIterableToUint8Array } from './uint8Array.js';
+const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+// Use minimal bytecode for testing - simple nop and return-void instructions
+const arbitraryMinimalBytecode = fc.array(fc.oneof(fc.constant({
+    operation: 'nop',
+}), fc.constant({
+    operation: 'return-void',
+})), { maxLength: 10 });
+testProp('dalvikExecutableUnparser roundtrip', [createArbitraryDalvikExecutable(arbitraryMinimalBytecode)], async (t, dalvikExecutable) => {
+    // Unparse to bytes
+    const unparsedIterable = runUnparser(dalvikExecutableUnparser, dalvikExecutable, uint8ArrayUnparserOutputCompanion);
+    const bytes = await uint8ArrayAsyncIterableToUint8Array(unparsedIterable);
+    // Re-parse
+    const reparsed = await runParser(dalvikExecutableParser, bytes, uint8ArrayParserInputCompanion, {
+        errorStack: true,
+    });
+    // Assert equality
+    t.deepEqual(reparsed, dalvikExecutable);
+}, {
+    verbose: true,
+    seed,
+});

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 -= 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.js

@@ -1,17 +1,28 @@
 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 { type DeriveSequenceElement } from './sequence.js';
+export declare const createDisjunctionParser: <Output, Sequence, Element = DeriveSequenceElement<Sequence>>(childParsers: Array<Parser<unknown, 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 { isParserParsingFailedError } 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,22 +10,23 @@ 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) {
+            if (isParserParsingFailedError(error)) {
                 parserParsingFailedErrors.push(error);
             }
             else {
                 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/elementTerminatedArrayParser.d.ts

@@ -0,0 +1,3 @@
+import { type Parser } from './parser.js';
+import { type 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(async () => runParser(createTestWrapperParser(terminatedArrayParserNaive), string, stringParserInputCompanion));
+    t.is(actualNaive.string.length, string.split(terminator)[0].length);
+    const actual = await elementTotalTimer.measureAsync(async () => runParser(createTestWrapperParser(elementTerminatedArrayParserUnsafe), string, stringParserInputCompanion));
+    t.deepEqual(actual, actualNaive);
+}, {
+    verbose: true,
+});
+test.serial('elementTerminatedArrayParserUnsafe performance', t => {
+    t.true(elementTotalTimer.time * 2n < naiveTotalTimer.time, `Naive: ${naiveTotalTimer.time / 1000000n}ms, Unsafe: ${elementTotalTimer.time / 1000000n}ms`);
+});

package/build/elementTerminatedSequenceArrayParser.d.ts

@@ -0,0 +1,3 @@
+import { type Parser } from './parser.js';
+import { type 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;
+};