@futpib/parser 1.0.1 → 1.0.3

package/build/apk.d.ts

@@ -1,39 +0,0 @@
-import { type Zip } from './zip.js';
-export type ApkSigningBlockPair = {
-    id: number;
-    value: Uint8Array;
-};
-export type ApkSignatureV2Digest = {
-    signatureAlgorithmId: number;
-    digest: Uint8Array;
-};
-export type ApkSignatureV2AdditionalAttribute = {
-    id: number;
-    value: Uint8Array;
-};
-export type ApkSignatureV2SignedData = {
-    digests: ApkSignatureV2Digest[];
-    certificates: Uint8Array[];
-    additionalAttributes: ApkSignatureV2AdditionalAttribute[];
-    zeroPaddingLength?: number;
-};
-export type ApkSignatureV2Signature = {
-    signatureAlgorithmId: number;
-    signature: Uint8Array;
-};
-export type ApkSignatureV2Signer = {
-    signedData: ApkSignatureV2SignedData;
-    signatures: ApkSignatureV2Signature[];
-    publicKey: Uint8Array;
-};
-export type ApkSignatureV2 = {
-    signers: ApkSignatureV2Signer[];
-};
-export type ApkSigningBlock = {
-    pairs: ApkSigningBlockPair[];
-    signatureV2?: ApkSignatureV2;
-    zeroPaddingLength?: number;
-};
-export type Apk = Zip & {
-    signingBlock?: ApkSigningBlock;
-};

package/build/apkParser.d.ts

@@ -1,16 +0,0 @@
-import { type Parser } from './parser.js';
-import { ZipCentralDirectoryHeader, ZipEndOfCentralDirectoryRecord, ZipLocalFile } from './zipParser.js';
-import { type Apk, type ApkSigningBlock } from './apk.js';
-export declare const apkSigningBlockParser: Parser<ApkSigningBlock, Uint8Array>;
-export declare const apkParser: Parser<Apk, Uint8Array>;
-export type ApkSignableSections = {
-    zipLocalFiles: ZipLocalFile[];
-    apkSigningBlock?: ApkSigningBlock;
-    zipCentralDirectory: ZipCentralDirectoryHeader[];
-    zipEndOfCentralDirectory: ZipEndOfCentralDirectoryRecord;
-    zipLocalFilesUint8Array: Uint8Array;
-    apkSigningBlockUint8Array?: Uint8Array;
-    zipCentralDirectoryUint8Array: Uint8Array;
-    zipEndOfCentralDirectoryUint8Array: Uint8Array;
-};
-export declare const apkSignableSectionsParser: Parser<ApkSignableSections, Uint8Array>;

package/build/apkParser.js

@@ -1,164 +0,0 @@
-import invariant from 'invariant';
-import { createArrayParser } from './arrayParser.js';
-import { createOptionalParser } from './optionalParser.js';
-import { setParserName } from './parser.js';
-import { promiseCompose } from './promiseCompose.js';
-import { createTupleParser } from './tupleParser.js';
-import { zip64EndOfCentralDirectoryLocatorParser, zip64EndOfCentralDirectoryRecordParser, zipArchiveDecryptionHeaderParser, zipArchiveExtraDataRecordParser, zipCentralDirectoryHeaderParser, zipEndOfCentralDirectoryRecordParser, zipFromZipSegments, zipLocalFileParser, } from './zipParser.js';
-import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
-import { parserCreatorCompose } from './parserCreatorCompose.js';
-import { createExactSequenceParser } from './exactSequenceParser.js';
-import { createSliceBoundedParser } from './sliceBoundedParser.js';
-import { createDisjunctionParser } from './disjunctionParser.js';
-import { createExactElementParser } from './exactElementParser.js';
-import { createParserConsumedSequenceParser } from './parserConsumedSequenceParser.js';
-// https://source.android.com/docs/security/features/apksigning/v2#apk-signing-block
-const uint32LEParser = promiseCompose(createFixedLengthSequenceParser(4), array => Buffer.from(array).readUInt32LE());
-setParserName(uint32LEParser, 'uint32LEParser');
-const uint64LEParser = promiseCompose(createFixedLengthSequenceParser(8), array => Buffer.from(array).readBigUInt64LE());
-setParserName(uint64LEParser, 'uint64LEParser');
-const createUint32LengthPrefixedParser = (createInnerParser) => parserCreatorCompose(() => uint32LEParser, length => createInnerParser(length))();
-const createUint64LengthPrefixedParser = (createInnerParser) => parserCreatorCompose(() => uint64LEParser, length => createInnerParser(length))();
-const createUint32LengthPrefixedSliceBoundedParser = (innerParser) => createUint32LengthPrefixedParser(length => createSliceBoundedParser(innerParser, length));
-const createUint32LengthPrefixedSliceBoundedArrayParser = (innerParser) => createUint32LengthPrefixedSliceBoundedParser(createArrayParser(innerParser));
-const createApkSigningBlockZeroPaddingPairInnerParser = (length) => promiseCompose(createTupleParser([
-    createExactSequenceParser(Buffer.from('77657242', 'hex')),
-    createFixedLengthSequenceParser(length - 4),
-]), ([_magic, zeroPadding]) => ({ type: 'zeroPadding', length: zeroPadding.length }));
-const createApkSigningBlockSignatureV2PairInnerParser = (length) => {
-    const apkSigningBlockSignatureV2PairInnerParser = promiseCompose(createTupleParser([
-        createExactSequenceParser(Buffer.from('1a870971', 'hex')),
-        apkSignatureV2SignersParser,
-    ]), ([_magic, signers = []]) => ({ type: 'signatureV2', signers }));
-    return setParserName(apkSigningBlockSignatureV2PairInnerParser, 'apkSigningBlockSignatureV2PairInnerParser');
-};
-const createApkSigningBlockGenericPairInnerParser = (length) => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createFixedLengthSequenceParser(length - 4),
-]), ([id, value]) => ({ type: 'generic', pair: { id, value } }));
-const createApkSigningBlockPairInnerParser = (length) => createDisjunctionParser([
-    createApkSigningBlockZeroPaddingPairInnerParser(length),
-    createApkSigningBlockSignatureV2PairInnerParser(length),
-    createApkSigningBlockGenericPairInnerParser(length),
-]);
-const apkSigningBlockPairParser = createUint64LengthPrefixedParser(length => createApkSigningBlockPairInnerParser(Number(length)));
-setParserName(apkSigningBlockPairParser, 'apkSigningBlockPairParser');
-const apkSigningBlockPairsParser = createArrayParser(apkSigningBlockPairParser);
-export const apkSigningBlockParser = createUint64LengthPrefixedParser(sizeOfBlock => promiseCompose(createTupleParser([
-    apkSigningBlockPairsParser,
-    uint64LEParser,
-    createExactSequenceParser(Buffer.from('APK Sig Block 42', 'utf8')),
-]), async ([pairs, sizeOfBlockRepeated, _magic]) => {
-    invariant(sizeOfBlock === sizeOfBlockRepeated, 'Size of block mismatch: %s !== %s.', sizeOfBlock, sizeOfBlockRepeated);
-    const zeroPaddingPair = pairs.find(pair => pair.type === 'zeroPadding');
-    const signatureV2Pair = pairs.find(pair => pair.type === 'signatureV2');
-    const genericPairs = (pairs
-        .filter(pair => (pair !== zeroPaddingPair
-        && pair !== signatureV2Pair))
-        .map(pair => {
-        invariant(pair.type === 'generic', 'Expected generic pair, got %s.', pair.type);
-        return pair.pair;
-    }));
-    return {
-        zeroPaddingLength: zeroPaddingPair?.length,
-        signatureV2: signatureV2Pair ? {
-            signers: signatureV2Pair?.signers,
-        } : undefined,
-        pairs: genericPairs,
-    };
-}));
-const apkSignatureV2DigestParser = createUint32LengthPrefixedParser(pairLength => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createUint32LengthPrefixedParser(digestLength => createFixedLengthSequenceParser(digestLength)),
-]), ([signatureAlgorithmId, digest]) => ({ signatureAlgorithmId, digest })));
-const apkSignatureV2DigestsParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureV2DigestParser);
-const apkSignatureV2CertificateParser = createUint32LengthPrefixedParser(certificateLength => createFixedLengthSequenceParser(certificateLength));
-const apkSignatureV2CertificatesParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureV2CertificateParser);
-const apkSignatureV2AdditionalAttributeParser = createUint32LengthPrefixedParser(pairLength => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createFixedLengthSequenceParser(pairLength - 4),
-]), ([id, value]) => ({ id, value })));
-setParserName(apkSignatureV2AdditionalAttributeParser, 'apkSignatureV2AdditionalAttributeParser');
-const apkSignatureV2AdditionalAttributesParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureV2AdditionalAttributeParser);
-setParserName(apkSignatureV2AdditionalAttributesParser, 'apkSignatureV2AdditionalAttributesParser');
-const apkSignatureV2SignedDataParser = createUint32LengthPrefixedSliceBoundedParser(promiseCompose(createTupleParser([
-    apkSignatureV2DigestsParser,
-    apkSignatureV2CertificatesParser,
-    apkSignatureV2AdditionalAttributesParser,
-    createArrayParser(createExactElementParser(0)),
-]), ([digests, certificates, additionalAttributes, zeroPadding,]) => ({
-    digests,
-    certificates,
-    additionalAttributes,
-    zeroPaddingLength: zeroPadding.length,
-})));
-setParserName(apkSignatureV2SignedDataParser, 'apkSignatureV2SignedDataParser');
-const apkSignatureV2SignatureParser = createUint32LengthPrefixedParser(signatureLength => promiseCompose(createTupleParser([
-    uint32LEParser,
-    createUint32LengthPrefixedParser(signatureLength => createFixedLengthSequenceParser(signatureLength)),
-]), ([signatureAlgorithmId, signature,]) => ({
-    signatureAlgorithmId,
-    signature,
-})));
-const apkSignatureV2SignaturesParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureV2SignatureParser);
-setParserName(apkSignatureV2SignaturesParser, 'apkSignatureV2SignaturesParser');
-const apkSignatureV2PublicKeyParser = createUint32LengthPrefixedParser(publicKeyLength => createFixedLengthSequenceParser(publicKeyLength));
-setParserName(apkSignatureV2PublicKeyParser, 'apkSignatureV2PublicKeyParser');
-const apkSignatureV2SignerParser = createUint32LengthPrefixedSliceBoundedParser(promiseCompose(createTupleParser([
-    apkSignatureV2SignedDataParser,
-    apkSignatureV2SignaturesParser,
-    apkSignatureV2PublicKeyParser,
-]), ([signedData, signatures = [], publicKey,]) => ({
-    signedData,
-    signatures,
-    publicKey,
-})));
-setParserName(apkSignatureV2SignerParser, 'apkSignatureV2SignerParser');
-const apkSignatureV2SignersParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureV2SignerParser);
-setParserName(apkSignatureV2SignersParser, 'apkSignatureV2SignersParser');
-const apkParser_ = createTupleParser([
-    createArrayParser(zipLocalFileParser),
-    createOptionalParser(zipArchiveDecryptionHeaderParser),
-    createOptionalParser(zipArchiveExtraDataRecordParser),
-    createOptionalParser(apkSigningBlockParser),
-    createArrayParser(zipCentralDirectoryHeaderParser),
-    createOptionalParser(zip64EndOfCentralDirectoryRecordParser),
-    createOptionalParser(zip64EndOfCentralDirectoryLocatorParser),
-    zipEndOfCentralDirectoryRecordParser,
-]);
-setParserName(apkParser_, 'apkParser_');
-export const apkParser = promiseCompose(apkParser_, async ([zipLocalFiles, zipArchiveDecryptionHeader, zipArchiveExtraDataRecord, apkSigningBlock, zipCentralDirectoryHeaders, zip64EndOfCentralDirectoryRecord, zip64EndOfCentralDirectoryLocator, zipEndOfCentralDirectoryRecord,]) => {
-    const zip = await zipFromZipSegments({
-        zipLocalFiles,
-        zipCentralDirectoryHeaders,
-        zipEndOfCentralDirectoryRecord,
-    });
-    return {
-        ...zip,
-        signingBlock: apkSigningBlock,
-    };
-});
-setParserName(apkParser, 'apkParser');
-export const apkSignableSectionsParser = promiseCompose(createTupleParser([
-    createParserConsumedSequenceParser(createTupleParser([
-        createArrayParser(zipLocalFileParser),
-        createOptionalParser(zipArchiveDecryptionHeaderParser),
-        createOptionalParser(zipArchiveExtraDataRecordParser),
-    ])),
-    createOptionalParser(createParserConsumedSequenceParser(apkSigningBlockParser)),
-    createParserConsumedSequenceParser(createTupleParser([
-        createArrayParser(zipCentralDirectoryHeaderParser),
-        createOptionalParser(zip64EndOfCentralDirectoryRecordParser),
-        createOptionalParser(zip64EndOfCentralDirectoryLocatorParser),
-    ])),
-    createParserConsumedSequenceParser(zipEndOfCentralDirectoryRecordParser),
-]), async ([[[zipLocalFiles,], zipLocalFilesUint8Array,], [apkSigningBlock = undefined, apkSigningBlockUint8Array = undefined,] = [], [[zipCentralDirectory,], zipCentralDirectoryUint8Array,], [zipEndOfCentralDirectory, zipEndOfCentralDirectoryUint8Array,],]) => ({
-    zipLocalFiles,
-    apkSigningBlock,
-    zipCentralDirectory,
-    zipEndOfCentralDirectory,
-    zipLocalFilesUint8Array,
-    apkSigningBlockUint8Array,
-    zipCentralDirectoryUint8Array,
-    zipEndOfCentralDirectoryUint8Array,
-}));

package/build/apkParser.test.js

@@ -1,22 +0,0 @@
-import test from 'ava';
-import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
-import { runParser } from './parser.js';
-import { apkParser } from './apkParser.js';
-for (const apkCid of [
-    'bafkreicckcmzrdxwoc3w2in3tivpyxrdtcfpct4zwauq3igew3nkpvfapu',
-    'bafkreidqycbgrtp7ywhevsgtm464dqpamxsijpaqfcfz2k3ymc3wrzsb5m',
-]) {
-    test('apk ' + apkCid, async (t) => {
-        const apkResponse = await fetch('https://ipfs.io/ipfs/' + apkCid);
-        const apkStream = apkResponse.body;
-        const actual = await runParser(apkParser, apkStream, uint8ArrayParserInputCompanion, {
-            errorJoinMode: 'all',
-        });
-        for (const entry of actual.entries) {
-            if (entry.type === 'file') {
-                entry.content = new Uint8Array([entry.content.length]);
-            }
-        }
-        t.snapshot(actual);
-    });
-}

package/build/apkUnparser.d.ts

@@ -1,4 +0,0 @@
-import { ApkSignatureV2SignedData, ApkSigningBlock } from "./apk.js";
-import { Unparser } from "./unparser.js";
-export declare const apkSignatureV2SignedDataUnparser: Unparser<ApkSignatureV2SignedData, Uint8Array>;
-export declare const apkSigningBlockUnparser: Unparser<ApkSigningBlock, Uint8Array>;

package/build/apkUnparser.js

@@ -1,90 +0,0 @@
-import { createArrayUnparser } from "./arrayUnparser.js";
-import { createSequenceUnparser } from "./sequenceUnparser.js";
-const uint8ArrayUnparser = createSequenceUnparser();
-const uint32LEUnparser = async function* (input) {
-    const buffer = Buffer.alloc(4);
-    buffer.writeUInt32LE(input);
-    yield buffer;
-};
-const uint64LEUnparser = async function* (input) {
-    const buffer = Buffer.alloc(8);
-    buffer.writeBigUInt64LE(BigInt(input));
-    yield buffer;
-};
-const createUint32LengthPrefixedUnparser = (innerUnparser) => async function* (input, unparserContext) {
-    const length = yield* unparserContext.writeLater(4);
-    yield* innerUnparser(input, unparserContext);
-    yield* unparserContext.writeEarlier(length, uint32LEUnparser, unparserContext.position - length.positionEnd);
-};
-const createUint64LengthPrefixedUnparser = (innerUnparser) => async function* (input, unparserContext) {
-    const length = yield* unparserContext.writeLater(8);
-    yield* innerUnparser(input, unparserContext);
-    yield* unparserContext.writeEarlier(length, uint64LEUnparser, unparserContext.position - length.positionEnd);
-};
-const apkSignatureV2DigestUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
-    yield* uint32LEUnparser(input.signatureAlgorithmId, unparserContext);
-    yield* uint32LEUnparser(input.digest.length, unparserContext);
-    yield input.digest;
-});
-const apkSignatureV2DigestsUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2DigestUnparser));
-const apkSignatureV2CertificateUnparser = createUint32LengthPrefixedUnparser(uint8ArrayUnparser);
-const apkSignatureV2CertificatesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2CertificateUnparser));
-const apkSignatureV2AdditionalAttributeUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
-    yield* uint32LEUnparser(input.id, unparserContext);
-    yield input.value;
-});
-const apkSignatureV2AdditionalAttributesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2AdditionalAttributeUnparser));
-export const apkSignatureV2SignedDataUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
-    yield* apkSignatureV2DigestsUnparser(input.digests, unparserContext);
-    yield* apkSignatureV2CertificatesUnparser(input.certificates, unparserContext);
-    yield* apkSignatureV2AdditionalAttributesUnparser(input.additionalAttributes, unparserContext);
-    if (input.zeroPaddingLength) {
-        yield Buffer.alloc(input.zeroPaddingLength);
-    }
-});
-const apkSignatureV2SignatureUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
-    yield* uint32LEUnparser(input.signatureAlgorithmId, unparserContext);
-    yield* uint32LEUnparser(input.signature.length, unparserContext);
-    yield input.signature;
-});
-const apkSignatureV2SignaturesUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2SignatureUnparser));
-const apkSignatureV2PublicKeyUnparser = createUint32LengthPrefixedUnparser(uint8ArrayUnparser);
-const apkSignatureV2SignerUnparser = createUint32LengthPrefixedUnparser(async function* (input, unparserContext) {
-    yield* apkSignatureV2SignedDataUnparser(input.signedData, unparserContext);
-    yield* apkSignatureV2SignaturesUnparser(input.signatures, unparserContext);
-    yield* apkSignatureV2PublicKeyUnparser(input.publicKey, unparserContext);
-});
-const apkSignatureV2SignersUnparser = createUint32LengthPrefixedUnparser(createArrayUnparser(apkSignatureV2SignerUnparser));
-const apkSigningBlockPairUnparser = createUint64LengthPrefixedUnparser(async function* (input, unparserContext) {
-    yield* uint32LEUnparser(input.id, unparserContext);
-    if (input.value instanceof Uint8Array) {
-        yield input.value;
-    }
-    else {
-        yield* apkSignatureV2SignersUnparser(input.value, unparserContext);
-    }
-});
-const apkSigningBlockPairsUnparser = createArrayUnparser(apkSigningBlockPairUnparser);
-export const apkSigningBlockUnparser = async function* (input, unparserContext) {
-    const pairs = [
-        ...input.pairs,
-        ...(input.signatureV2 ? [
-            {
-                id: 0x7109871a,
-                value: input.signatureV2.signers,
-            },
-        ] : []),
-        ...(input.zeroPaddingLength ? [
-            {
-                id: 0x42726577,
-                value: Buffer.alloc(input.zeroPaddingLength),
-            },
-        ] : []),
-    ];
-    const sizeOfBlockWriteLater = yield* unparserContext.writeLater(8);
-    yield* apkSigningBlockPairsUnparser(pairs, unparserContext);
-    const sizeOfBlock = unparserContext.position - sizeOfBlockWriteLater.position + 16;
-    yield* uint64LEUnparser(sizeOfBlock, unparserContext);
-    yield* unparserContext.writeEarlier(sizeOfBlockWriteLater, uint64LEUnparser, sizeOfBlock);
-    yield Buffer.from('APK Sig Block 42', 'utf8');
-};

package/build/apkUnparser.test.js

@@ -1,26 +0,0 @@
-import test from 'ava';
-import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
-import { runParser } from './parser.js';
-import { apkParser, apkSigningBlockParser } from './apkParser.js';
-import { runUnparser } from './unparser.js';
-import { apkSigningBlockUnparser } from './apkUnparser.js';
-import { uint8ArrayUnparserOutputCompanion } from './unparserOutputCompanion.js';
-import invariant from 'invariant';
-for (const apkCid of [
-    'bafkreicckcmzrdxwoc3w2in3tivpyxrdtcfpct4zwauq3igew3nkpvfapu',
-]) {
-    test('apk ' + apkCid, async (t) => {
-        const apkResponse = await fetch('https://ipfs.io/ipfs/' + apkCid);
-        const apkStream = apkResponse.body;
-        const apk = await runParser(apkParser, apkStream, uint8ArrayParserInputCompanion, {
-            errorJoinMode: 'all',
-        });
-        const apkSigningBlock = apk.signingBlock;
-        invariant(apkSigningBlock, 'APK has no signing block');
-        const apkSigningBlockStream = runUnparser(apkSigningBlockUnparser, apkSigningBlock, uint8ArrayUnparserOutputCompanion);
-        const actual = await runParser(apkSigningBlockParser, apkSigningBlockStream, uint8ArrayParserInputCompanion, {
-            errorJoinMode: 'all',
-        });
-        t.deepEqual(actual, apkSigningBlock);
-    });
-}

package/build/arbitraryDosDate.d.ts

@@ -1,2 +0,0 @@
-import * as fc from 'fast-check';
-export declare const arbitraryDosDateTime: fc.Arbitrary<Date>;

package/build/arbitraryDosDate.js

@@ -1,8 +0,0 @@
-import * as fc from 'fast-check';
-export const arbitraryDosDateTime = fc.date({
-    min: new Date(Date.UTC(1980, 0, 1)),
-    max: new Date(Date.UTC(2099, 11, 31)),
-}).map(date => {
-    date.setMilliseconds(0);
-    return date;
-});

package/build/arbitraryZipEntry.d.ts

@@ -1,3 +0,0 @@
-import * as fc from 'fast-check';
-import { ZipDirectoryEntry, ZipFileEntry } from './zip.js';
-export declare const arbitraryZipEntry: fc.Arbitrary<ZipFileEntry | ZipDirectoryEntry>;

package/build/arbitraryZipEntry.js

@@ -1,26 +0,0 @@
-import * as fc from 'fast-check';
-export const arbitraryZipEntry = fc.letrec((tie) => ({
-    entry: fc.oneof(fc.record({
-        type: fc.constant('file'),
-        name: fc.string({ minLength: 1 }),
-        date: fc.date(),
-        comment: fc.uint8Array(),
-        unixPermissions: fc.integer(),
-        dosPermissions: fc.integer(),
-        compression: fc.oneof(fc.record({
-            type: fc.constant('store'),
-        }), fc.record({
-            type: fc.constant('deflate'),
-            level: fc.nat({ max: 9 }),
-        })),
-        content: fc.uint8Array(),
-    }), fc.record({
-        type: fc.constant('directory'),
-        name: fc.string({ minLength: 1 }),
-        date: fc.date(),
-        comment: fc.uint8Array(),
-        unixPermissions: fc.integer(),
-        dosPermissions: fc.integer(),
-        entries: fc.array(tie('entry')),
-    })),
-})).entry;

package/build/createDisjunctionParser.d.ts

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

package/build/createDisjunctionParser.js

@@ -1,47 +0,0 @@
-import { ParserParsingFailedError } from './parserError.js';
-import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-import { parserParsingInvariant } from './parserParsingInvariant.js';
-function getParserName(parser) {
-    return parser.name || 'anonymousDisjunctionChild';
-}
-export const createDisjunctionParser = (childParsers) => {
-    parserImplementationInvariant(childParsers.length > 0, 'Disjunction parser must have at least one child parser.');
-    const disjunctionParser = async (parserContext) => {
-        const parserParsingFailedErrors = [];
-        for (const childParser of childParsers) {
-            const childParserContext = parserContext.lookahead(getParserName(childParser));
-            const [childParserResult] = await Promise.allSettled([childParser(childParserContext)]);
-            if (childParserResult.status === 'fulfilled') {
-                const successfulParserOutput = childParserResult.value;
-                childParserContext.unlookahead();
-                childParserContext.dispose();
-                return successfulParserOutput;
-            }
-            else {
-                const error = childParserResult.reason;
-                if (error instanceof ParserParsingFailedError) {
-                    parserParsingFailedErrors.push(error);
-                }
-                else {
-                    throw error;
-                }
-            }
-        }
-        parserParsingInvariant(false, [
-            'No disjunction child parser succeeded.',
-            'Parsing errors, indented, separated by newlines:',
-            '%s',
-            'End of parsing errors.',
-        ], parserParsingFailedErrors
-            .flatMap(error => error.stack?.split('\n'))
-            .map(line => '  ' + line)
-            .join('\n'));
-    };
-    const name = [
-        '(',
-        ...childParsers.map(getParserName).join('|'),
-        ')',
-    ].join('');
-    Object.defineProperty(disjunctionParser, 'name', { value: name });
-    return disjunctionParser;
-};

package/build/createExactParser.d.ts

@@ -1,2 +0,0 @@
-import { type Parser } from './parser.js';
-export declare const createExactParser: <InputChunk>(inputChunk: InputChunk) => Parser<InputChunk, InputChunk, unknown>;

package/build/createExactParser.js

@@ -1,12 +0,0 @@
-import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-export const createExactParser = (inputChunk) => {
-    parserImplementationInvariant(length > 0, 'Length must be positive.');
-    return async (parserContext) => {
-        const elements = [];
-        for (let i = 0; i < length; i++) {
-            const element = await parserContext.read(0);
-            elements.push(element);
-        }
-        return parserContext.from(elements);
-    };
-};

package/build/createSequentialUnionParser.d.ts

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

package/build/createSequentialUnionParser.js

@@ -1,69 +0,0 @@
-import { ParserParsingFailedError } from './parserError.js';
-import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-import { parserParsingInvariant } from './parserParsingInvariant.js';
-function getParserName(parser) {
-    return parser.name || 'anonymousSequentialUnionChild';
-}
-export const createDisjunctionParser = (childParsers) => {
-    parserImplementationInvariant(childParsers.length > 0, 'SequentialUnion parser must have at least one child parser.');
-    const sequentialUnionParser = async (parserContext) => {
-        let runningChildParserContexts = [];
-        const childParserResults = (async function* () {
-            for (const childParser of childParsers) {
-                const childParserContext = parserContext.lookahead(getParserName(childParser));
-                runningChildParserContexts.push(childParserContext);
-                const [promiseSettledResult] = await Promise.allSettled([childParser(childParserContext)]);
-                yield {
-                    ...promiseSettledResult,
-                    context: childParserContext,
-                };
-            }
-        })();
-        const parserParsingFailedErrors = [];
-        const successfulParserOutputs = [];
-        const successfulParserContexts = [];
-        for await (const childParserResult of childParserResults) {
-            runningChildParserContexts = runningChildParserContexts.filter(runningChildParserContext => runningChildParserContext !== childParserResult.context);
-            if (childParserResult.status === 'fulfilled') {
-                successfulParserOutputs.push(childParserResult.value);
-                successfulParserContexts.push(childParserResult.context);
-            }
-            else {
-                const error = childParserResult.reason;
-                if (error instanceof ParserParsingFailedError) {
-                    parserParsingFailedErrors.push(error);
-                }
-                else {
-                    throw error;
-                }
-            }
-        }
-        parserImplementationInvariant(successfulParserOutputs.length <= 1, [
-            'Multiple sequentialUnion child parsers succeeded.',
-            'Successful parser outputs, indented, separated by newlines:',
-            '%s',
-            'End of successful parser outputs.',
-        ], successfulParserOutputs.map(output => '  ' + JSON.stringify(output)).join('\n'));
-        parserParsingInvariant(successfulParserOutputs.length === 1, [
-            'No sequentialUnion child parser succeeded.',
-            'Parsing errors, indented, separated by newlines:',
-            '%s',
-            'End of parsing errors.',
-        ], parserParsingFailedErrors
-            .flatMap(error => error.stack?.split('\n'))
-            .map(line => '  ' + line)
-            .join('\n'));
-        const [successfulParserContext] = successfulParserContexts;
-        successfulParserContext.unlookahead();
-        successfulParserContext.dispose();
-        const [successfulParserOutput] = successfulParserOutputs;
-        return successfulParserOutput;
-    };
-    const name = [
-        '(',
-        ...childParsers.map(getParserName).join('|'),
-        ')',
-    ].join('');
-    Object.defineProperty(sequentialUnionParser, 'name', { value: name });
-    return sequentialUnionParser;
-};

package/build/fixedLengthChunkParser.d.ts

@@ -1,2 +0,0 @@
-import { type Parser } from './parser.js';
-export declare const createFixedLengthParser: <InputChunk>(length: number) => Parser<InputChunk, InputChunk, unknown>;

package/build/fixedLengthChunkParser.js

@@ -1,12 +0,0 @@
-import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-export const createFixedLengthParser = (length) => {
-    parserImplementationInvariant(length > 0, 'Length must be positive.');
-    return async (parserContext) => {
-        const elements = [];
-        for (let i = 0; i < length; i++) {
-            const element = await parserContext.read(0);
-            elements.push(element);
-        }
-        return parserContext.from(elements);
-    };
-};

package/build/fixedLengthParser.d.ts

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

package/build/fixedLengthParser.js

@@ -1,12 +0,0 @@
-import { parserImplementationInvariant } from './parserImplementationInvariant.js';
-export const createFixedLengthSequenceParser = (length) => {
-    parserImplementationInvariant(length >= 0, 'Length must be non-negative got %s.', length);
-    return async (parserContext) => {
-        const elements = [];
-        for (let i = 0; i < length; i++) {
-            const element = await parserContext.read(0);
-            elements.push(element);
-        }
-        return parserContext.from(elements);
-    };
-};

package/build/inputChunkBuffer.d.ts

@@ -1,15 +0,0 @@
-import { type InputCompanion } from './inputCompanion.js';
-export interface SequenceBuffer<Sequence, InputElement> {
-    push(sequence: Sequence): void;
-    peek(offset: number): InputElement | undefined;
-    skip(offset: number): void;
-}
-export declare class SequenceBufferImplementation<Sequence, InputElement> implements SequenceBuffer<Sequence, InputElement> {
-    private readonly _inputCompanion;
-    private readonly _sequences;
-    private _indexInFirstSequence;
-    constructor(_inputCompanion: InputCompanion<Sequence, InputElement>);
-    push(sequence: Sequence): void;
-    peek(offset: number): InputElement | undefined;
-    skip(offset: number): void;
-}

package/build/inputChunkBuffer.js

@@ -1,40 +0,0 @@
-import invariant from 'invariant';
-export class SequenceBufferImplementation {
-    _inputCompanion;
-    _sequences = [];
-    _indexInFirstSequence = 0;
-    constructor(_inputCompanion) {
-        this._inputCompanion = _inputCompanion;
-    }
-    push(sequence) {
-        this._sequences.push(sequence);
-        while (this._sequences.length > 0) {
-            const firstSequence = this._sequences[0];
-            const firstSequenceLength = this._inputCompanion.length(firstSequence);
-            if (firstSequenceLength === 0) {
-                this._sequences.shift();
-                continue;
-            }
-            if (this._indexInFirstSequence < firstSequenceLength) {
-                break;
-            }
-            this._sequences.shift();
-            this._indexInFirstSequence -= firstSequenceLength;
-        }
-    }
-    peek(offset) {
-        invariant(offset >= 0, 'Offset must be non-negative.');
-        let index = this._indexInFirstSequence + offset;
-        for (const sequence of this._sequences) {
-            const sequenceLength = this._inputCompanion.length(sequence);
-            if (index < sequenceLength) {
-                return this._inputCompanion.at(sequence, index);
-            }
-            index -= sequenceLength;
-        }
-        return undefined;
-    }
-    skip(offset) {
-        this._indexInFirstSequence += offset;
-    }
-}