@futpib/parser 1.0.0

package/.yarnrc.yml

@@ -0,0 +1,7 @@
+compressionLevel: mixed
+
+enableGlobalCache: false
+
+nodeLinker: node-modules
+
+yarnPath: .yarn/releases/yarn-4.5.3.cjs

package/build/allSettledStream.d.ts

@@ -0,0 +1,17 @@
+type AllSettledStreamFulfilledResult<T, Context> = {
+    status: 'fulfilled';
+    value: T;
+    context: Context;
+};
+type AllSettledStreamRejectedResult<T, Context> = {
+    status: 'rejected';
+    reason: unknown;
+    context: Context;
+};
+type AllSettedStreamResult<T, Context> = AllSettledStreamFulfilledResult<T, Context> | AllSettledStreamRejectedResult<T, Context>;
+type AllSettledStreamTask<T, Context> = {
+    promise: Promise<T>;
+    context: Context;
+};
+export declare function allSettledStream<T, Context>(tasks: Array<AllSettledStreamTask<T, Context>>): ReadableStream<AllSettedStreamResult<T, Context>>;
+export {};

package/build/allSettledStream.js

@@ -0,0 +1,21 @@
+export function allSettledStream(tasks) {
+    return new ReadableStream({
+        async start(controller) {
+            let settledCount = 0;
+            for (const { promise, context } of tasks) {
+                (async () => {
+                    const [promiseSettledResult] = await Promise.allSettled([promise]);
+                    settledCount++;
+                    const allSettedStreamResult = {
+                        ...promiseSettledResult,
+                        context,
+                    };
+                    controller.enqueue(allSettedStreamResult);
+                    if (settledCount === tasks.length) {
+                        controller.close();
+                    }
+                })();
+            }
+        },
+    });
+}

package/build/allSettledStream.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/allSettledStream.test.js

@@ -0,0 +1,56 @@
+import test from 'ava';
+import { allSettledStream } from './allSettledStream.js';
+test('allSettledStream', async (t) => {
+    const stream = allSettledStream([
+        {
+            delay: 10,
+            context: 1,
+        },
+        {
+            delay: 10,
+            context: 'a',
+        },
+        {
+            delay: 20,
+            context: 2,
+        },
+        {
+            delay: 20,
+            context: 'b',
+        },
+        {
+            delay: 0,
+            context: 3,
+        },
+        {
+            delay: 0,
+            context: 'c',
+        },
+        {
+            delay: 40,
+            context: 4,
+        },
+        {
+            delay: 40,
+            context: 'd',
+        },
+    ].map(({ delay, context }) => ({
+        promise: new Promise((resolve, reject) => {
+            setTimeout(() => {
+                if (typeof context === 'number') {
+                    resolve(context);
+                }
+                else {
+                    reject(context);
+                }
+            }, delay);
+        }),
+        context,
+    })));
+    const results = [];
+    for await (const value of stream) {
+        results.push(value);
+    }
+    t.snapshot(results);
+    t.is(results.length, 8);
+});

package/build/apk.d.ts

@@ -0,0 +1,13 @@
+import { Zip } from './zip.js';
+export type ApkSigningBlockPair = {
+    id: number;
+    value: Uint8Array;
+};
+export type ApkSigningBlock = {
+    zeroPaddingLength?: number;
+    signatureV2?: unknown;
+    pairs: ApkSigningBlockPair[];
+};
+export type Apk = Zip & {
+    signingBlock?: ApkSigningBlock;
+};

package/build/apk.js

@@ -0,0 +1 @@
+export {};

package/build/apkParser.d.ts

@@ -0,0 +1,3 @@
+import { Parser } from "./parser.js";
+import { Apk } from "./apk.js";
+export declare const apkParser: Parser<Apk, Uint8Array>;

package/build/apkParser.js

@@ -0,0 +1,135 @@
+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 invariant from "invariant";
+import { createExactElementParser } from "./exactElementParser.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')),
+        apkSignatureSchemeV2SignersParser,
+    ]), ([_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);
+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,
+        pairs: genericPairs,
+    };
+}));
+const apkSignatureSchemeV2DigestParser = createUint32LengthPrefixedParser(pairLength => promiseCompose(createTupleParser([
+    uint32LEParser,
+    createUint32LengthPrefixedParser(digestLength => createFixedLengthSequenceParser(digestLength)),
+]), ([signatureAlgorithmId, digest]) => ({ signatureAlgorithmId, digest })));
+const apkSignatureSchemeV2DigestsParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureSchemeV2DigestParser);
+const apkSignatureSchemeV2CertificateParser = createUint32LengthPrefixedParser(certificateLength => createFixedLengthSequenceParser(certificateLength));
+const apkSignatureSchemeV2CertificatesParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureSchemeV2CertificateParser);
+const apkSignatureSchemeV2AdditionalAttributeParser = createUint32LengthPrefixedParser(pairLength => promiseCompose(createTupleParser([
+    uint32LEParser,
+    createFixedLengthSequenceParser(pairLength - 4),
+]), ([id, value]) => ({ id, value })));
+const apkSignatureSchemeV2AdditionalAttributesParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureSchemeV2AdditionalAttributeParser);
+const apkSignatureSchemeV2SignedDataParser = createUint32LengthPrefixedSliceBoundedParser(promiseCompose(createTupleParser([
+    apkSignatureSchemeV2DigestsParser,
+    apkSignatureSchemeV2CertificatesParser,
+    createOptionalParser(apkSignatureSchemeV2AdditionalAttributesParser),
+    createArrayParser(createExactElementParser(0)),
+]), ([digests = [], certificates = [], additionalAttributes = [],]) => ({
+    digests,
+    certificates,
+    additionalAttributes,
+})));
+setParserName(apkSignatureSchemeV2SignedDataParser, 'apkSignatureSchemeV2SignedDataParser');
+const apkSignatureSchemeV2SignatureParser = createUint32LengthPrefixedParser(signatureLength => promiseCompose(createTupleParser([
+    uint32LEParser,
+    createUint32LengthPrefixedParser(signatureLength => createFixedLengthSequenceParser(signatureLength)),
+]), ([signatureAlgorithmId, signature,]) => ({
+    signatureAlgorithmId,
+    signature,
+})));
+const apkSignatureSchemeV2SignaturesParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureSchemeV2SignatureParser);
+setParserName(apkSignatureSchemeV2SignaturesParser, 'apkSignatureSchemeV2SignaturesParser');
+const apkSignatureSchemeV2PublicKeyParser = createUint32LengthPrefixedParser(publicKeyLength => createFixedLengthSequenceParser(publicKeyLength));
+setParserName(apkSignatureSchemeV2PublicKeyParser, 'apkSignatureSchemeV2PublicKeyParser');
+const apkSignatureSchemeV2SignerParser = createUint32LengthPrefixedSliceBoundedParser(promiseCompose(createTupleParser([
+    apkSignatureSchemeV2SignedDataParser,
+    apkSignatureSchemeV2SignaturesParser,
+    apkSignatureSchemeV2PublicKeyParser,
+]), ([signedData, signatures = [], publicKey]) => ({
+    signedData,
+    signatures,
+    publicKey,
+})));
+setParserName(apkSignatureSchemeV2SignerParser, 'apkSignatureSchemeV2SignerParser');
+const apkSignatureSchemeV2SignersParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureSchemeV2SignerParser);
+setParserName(apkSignatureSchemeV2SignersParser, 'apkSignatureSchemeV2SignersParser');
+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');

package/build/apkParser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/apkParser.test.js

@@ -0,0 +1,22 @@
+import test from 'ava';
+import { uint8ArrayInputCompanion } from './inputCompanion.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, uint8ArrayInputCompanion, {
+            errorJoinMode: 'all',
+        });
+        for (const entry of actual.entries) {
+            if (entry.type === 'file') {
+                entry.content = new Uint8Array([entry.content.length]);
+            }
+        }
+        t.snapshot(actual);
+    });
+}

package/build/arbitrarilySlicedAsyncInterable.d.ts

@@ -0,0 +1,2 @@
+import { type Arbitrary } from 'fast-check';
+export declare function arbitrarilySlicedAsyncIterable<Sliceable extends string | Uint8Array>(arbitrarySliceable: Arbitrary<Sliceable>): Arbitrary<[Sliceable, AsyncIterable<Sliceable>]>;

package/build/arbitrarilySlicedAsyncInterable.js

@@ -0,0 +1,46 @@
+import { inspect } from 'node:util';
+import * as fc from 'fast-check';
+import invariant from 'invariant';
+function concat(slices) {
+    const firstSlice = slices.at(0);
+    if (firstSlice instanceof Uint8Array) {
+        return Buffer.concat(slices);
+    }
+    return slices.join('');
+}
+function equals(a, b) {
+    if (a instanceof Uint8Array) {
+        return Buffer.compare(a, b) === 0;
+    }
+    return a === b;
+}
+export function arbitrarilySlicedAsyncIterable(arbitrarySliceable) {
+    return (fc.tuple(arbitrarySliceable, fc.array(fc.nat(), { minLength: 1 }))
+        .map(([sliceable, sliceSizes]) => {
+        let start = 0;
+        const slices = sliceSizes.map(sliceSize => {
+            const slice = sliceable.slice(start, start + sliceSize);
+            start += sliceSize;
+            return slice;
+        });
+        const lastSlice = sliceable.slice(start);
+        if (lastSlice.length > 0) {
+            slices.push(lastSlice);
+        }
+        const concatenated = concat(slices);
+        invariant(equals(concatenated, sliceable), [
+            'Slices do not concatenate to the original sliceable.',
+            'Original sliceable: %s.',
+            'Concatenated slices: %s.',
+            'Slice sizes: %s.',
+            'Slices: %s.',
+        ].join('\n'), inspect(sliceable), inspect(concatenated), inspect(sliceSizes), inspect(slices));
+        const asyncIterable = {
+            async *[Symbol.asyncIterator]() {
+                yield* slices;
+            },
+            [Symbol.toStringTag]: 'ArbitrarilySlicedAsyncIterable ' + slices.length + ' ' + JSON.stringify(slices),
+        };
+        return [sliceable, asyncIterable];
+    }));
+}

package/build/arbitrarilySlicedAsyncInterator.d.ts

@@ -0,0 +1,2 @@
+import { type Arbitrary } from 'fast-check';
+export declare function arbitrarilySlicedAsyncIterator<Sliceable extends string | Uint8Array>(arbitrarySliceable: Arbitrary<Sliceable>): Arbitrary<[Sliceable, AsyncIterator<Sliceable>]>;

package/build/arbitrarilySlicedAsyncInterator.js

@@ -0,0 +1,17 @@
+import { arbitrarilySlicedAsyncIterable } from './arbitrarilySlicedAsyncInterable.js';
+export function arbitrarilySlicedAsyncIterator(arbitrarySliceable) {
+    return (arbitrarilySlicedAsyncIterable(arbitrarySliceable)
+        .map(([sliceable, asyncIterable]) => {
+        const asyncIterator_ = asyncIterable[Symbol.asyncIterator]();
+        const asyncIterator = {
+            next: asyncIterator_.next.bind(asyncIterator_),
+            return: asyncIterator_.return?.bind(asyncIterator_),
+            throw: asyncIterator_.throw?.bind(asyncIterator_),
+            [Symbol.toStringTag]: 'ArbitrarilySlicedAsyncIterator ' + asyncIterable[Symbol.toStringTag],
+        };
+        return [
+            sliceable,
+            asyncIterator,
+        ];
+    }));
+}

package/build/arbitraryDosDate.d.ts

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

package/build/arbitraryDosDate.js

@@ -0,0 +1,8 @@
+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/arbitraryDosDateTime.d.ts

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

package/build/arbitraryDosDateTime.js

@@ -0,0 +1,9 @@
+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.setSeconds(0);
+    date.setMilliseconds(0);
+    return date;
+});

package/build/arbitraryDosPermissions.d.ts

@@ -0,0 +1 @@
+export {};

package/build/arbitraryDosPermissions.js

@@ -0,0 +1 @@
+export {};

package/build/arbitraryFileSystemEntry.d.ts

@@ -0,0 +1,14 @@
+import * as fc from 'fast-check';
+type FileSystemDirectory = {
+    type: 'directory';
+    name: string;
+    entries: FileSystemEntry[];
+};
+type FileSystemFile = {
+    type: 'file';
+    name: string;
+    content: Uint8Array;
+};
+export type FileSystemEntry = FileSystemFile | FileSystemDirectory;
+export declare const arbitraryFileSystemEntry: fc.Arbitrary<FileSystemFile | FileSystemDirectory>;
+export {};

package/build/arbitraryFileSystemEntry.js

@@ -0,0 +1,12 @@
+import * as fc from 'fast-check';
+export const arbitraryFileSystemEntry = fc.letrec((tie) => ({
+    entry: fc.oneof(fc.record({
+        type: fc.constant('file'),
+        name: fc.string(),
+        content: fc.uint8Array(),
+    }), fc.record({
+        type: fc.constant('directory'),
+        name: fc.string(),
+        entries: fc.array(tie('entry')),
+    })),
+})).entry;

package/build/arbitraryZip.d.ts

@@ -0,0 +1,6 @@
+import * as fc from 'fast-check';
+import { ZipEntry } from './zip.js';
+export declare const arbitraryZip: fc.Arbitrary<{
+    comment: string;
+    entries: ZipEntry[];
+}>;

package/build/arbitraryZip.js

@@ -0,0 +1,88 @@
+import * as fc from 'fast-check';
+import { arbitraryDosDateTime } from './arbitraryDosDateTime.js';
+import { createArbitraryZipPermissions } from './arbitraryZipPermissions.js';
+import invariant from 'invariant';
+const DOS_DIRECTORY_FLAG = 0b00010000;
+const arbitraryPath = fc.string({ minLength: 1 }).filter(path => {
+    const pathSegments = path.split('/');
+    const pathHasEmptySegments = pathSegments.some(segment => segment.length === 0);
+    if (pathHasEmptySegments) {
+        return false;
+    }
+    return true;
+});
+const createArbitraryZipEntry = (platform) => fc.oneof(fc.record({
+    type: fc.constant('file'),
+    path: arbitraryPath,
+    date: arbitraryDosDateTime,
+    comment: fc.string(),
+    permissions: createArbitraryZipPermissions(platform),
+    compression: fc.oneof(fc.constant('store'), fc.constant('deflate')),
+    content: fc.uint8Array(),
+}).filter(zipFileEntry => {
+    if (zipFileEntry.content.length === 0
+        && zipFileEntry.compression === 'deflate') {
+        return false;
+    }
+    if (zipFileEntry.permissions.type === 'dos'
+        && zipFileEntry.permissions.dosPermissions & DOS_DIRECTORY_FLAG) {
+        return false;
+    }
+    return true;
+}), fc.record({
+    type: fc.constant('directory'),
+    path: arbitraryPath,
+    date: arbitraryDosDateTime,
+    comment: fc.string(),
+    permissions: createArbitraryZipPermissions(platform),
+}).filter(zipDirectoryEntry => {
+    if (zipDirectoryEntry.permissions.type === 'dos'
+        && !(zipDirectoryEntry.permissions.dosPermissions & DOS_DIRECTORY_FLAG)) {
+        return false;
+    }
+    return true;
+}));
+const createArbitraryZipEntries = (platform) => (fc
+    .array(createArbitraryZipEntry(platform))
+    .map(entries => {
+    const seenPaths = new Set();
+    const seenDirectoryPaths = new Set();
+    const normalizedEntries = [];
+    for (const entry of entries) {
+        if (seenPaths.has(entry.path)) {
+            continue;
+        }
+        seenPaths.add(entry.path);
+        if (entry.type === 'directory') {
+            seenDirectoryPaths.add(entry.path);
+            continue;
+        }
+        invariant(entry.type === 'file', 'Unexpected entry type %s.', entry.type);
+        const directories = entry.path.split('/').slice(0, -1);
+        for (const depth of Array.from({ length: directories.length }).map((_, index) => index)) {
+            const directoryPath = directories.slice(0, depth + 1).join('/');
+            if (directoryPath.length === 0) {
+                continue;
+            }
+            if (!seenDirectoryPaths.has(directoryPath)) {
+                normalizedEntries.push({
+                    type: 'directory',
+                    path: directoryPath,
+                    date: entry.date,
+                    comment: '',
+                    permissions: entry.permissions.type === 'dos' ? {
+                        type: 'dos',
+                        dosPermissions: entry.permissions.dosPermissions | DOS_DIRECTORY_FLAG,
+                    } : entry.permissions,
+                });
+                seenDirectoryPaths.add(directoryPath);
+            }
+        }
+        normalizedEntries.push(entry);
+    }
+    return normalizedEntries;
+}));
+export const arbitraryZip = fc.oneof(fc.constant('unix'), fc.constant('dos')).chain(platform => fc.record({
+    comment: fc.string(),
+    entries: createArbitraryZipEntries(platform),
+}));

package/build/arbitraryZipEntry.d.ts

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

package/build/arbitraryZipEntry.js

@@ -0,0 +1,26 @@
+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/arbitraryZipPermissions.d.ts

@@ -0,0 +1,8 @@
+import * as fc from 'fast-check';
+export declare const createArbitraryZipPermissions: (type: "unix" | "dos") => fc.Arbitrary<{
+    type: "unix";
+    unixPermissions: number;
+}> | fc.Arbitrary<{
+    type: "dos";
+    dosPermissions: number;
+}>;

package/build/arbitraryZipPermissions.js

@@ -0,0 +1,16 @@
+import * as fc from 'fast-check';
+const arbitraryZipUnixPermissions = fc.record({
+    type: fc.constant('unix'),
+    unixPermissions: (fc.nat({ max: 0b0000000111111111 })
+        .filter((unixPermissions) => unixPermissions > 0)),
+});
+const arbitraryZipDosPermissions = fc.record({
+    type: fc.constant('dos'),
+    dosPermissions: (fc.nat({ max: 0b00111111 })),
+});
+export const createArbitraryZipPermissions = (type) => {
+    if (type === 'unix') {
+        return arbitraryZipUnixPermissions;
+    }
+    return arbitraryZipDosPermissions;
+};

package/build/arbitraryZipStream.d.ts

@@ -0,0 +1,5 @@
+import { ZipEntry } from './zip.js';
+export declare const arbitraryZipStream: import("fast-check").Arbitrary<readonly [{
+    comment: string;
+    entries: ZipEntry[];
+}, ReadableStream<Uint8Array<ArrayBufferLike>>]>;

package/build/arbitraryZipStream.js

@@ -0,0 +1,50 @@
+import JSZip from 'jszip';
+import { arbitraryZip } from './arbitraryZip.js';
+function addZipEntryToZip(zip, zipEntry) {
+    const options = {
+        comment: zipEntry.comment,
+        date: zipEntry.date,
+        unixPermissions: zipEntry.permissions.type === 'unix' ? zipEntry.permissions.unixPermissions : undefined,
+        dosPermissions: zipEntry.permissions.type === 'dos' ? zipEntry.permissions.dosPermissions : undefined,
+    };
+    if (zipEntry.type === 'file') {
+        zip.file(zipEntry.path, zipEntry.content, {
+            compression: zipEntry.compression.toUpperCase(),
+            compressionOptions: undefined,
+            binary: true,
+            ...options,
+        });
+    }
+    else {
+        zip.file(zipEntry.path, null, {
+            dir: true,
+            ...options,
+        });
+    }
+}
+export const arbitraryZipStream = arbitraryZip.map(zip => {
+    const jsZip = new JSZip();
+    for (const zipEntry of zip.entries) {
+        addZipEntryToZip(jsZip, zipEntry);
+    }
+    const zipInternalStream = jsZip.generateInternalStream({
+        type: 'uint8array',
+        comment: zip.comment,
+        platform: zip.entries.at(0)?.permissions.type.toUpperCase(),
+    });
+    const zipStream = new ReadableStream({
+        start(controller) {
+            zipInternalStream.on('data', (chunk) => {
+                controller.enqueue(chunk);
+            });
+            zipInternalStream.on('end', () => {
+                controller.close();
+            });
+            zipInternalStream.on('error', (error) => {
+                controller.error(error);
+            });
+            zipInternalStream.resume();
+        },
+    });
+    return [zip, zipStream];
+});

package/build/arrayParser.d.ts

@@ -0,0 +1,2 @@
+import { Parser } from "./parser.js";
+export declare const createArrayParser: <ElementOutput, Sequence>(elementParser: Parser<ElementOutput, Sequence>) => Parser<ElementOutput[], Sequence>;