@futpib/parser 1.0.0 → 1.0.1

package/build/apk.d.ts

@@ -1,12 +1,38 @@
-import { Zip } from './zip.js';
+import { type Zip } from './zip.js';
 export type ApkSigningBlockPair = {
     id: number;
     value: Uint8Array;
 };
-export type ApkSigningBlock = {
+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;
-    signatureV2?: unknown;
+};
+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,3 +1,16 @@
-import { Parser } from "./parser.js";
-import { Apk } from "./apk.js";
+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,16 +1,17 @@
-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";
+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');
@@ -27,7 +28,7 @@ const createApkSigningBlockZeroPaddingPairInnerParser = (length) => promiseCompo
 const createApkSigningBlockSignatureV2PairInnerParser = (length) => {
     const apkSigningBlockSignatureV2PairInnerParser = promiseCompose(createTupleParser([
         createExactSequenceParser(Buffer.from('1a870971', 'hex')),
-        apkSignatureSchemeV2SignersParser,
+        apkSignatureV2SignersParser,
     ]), ([_magic, signers = []]) => ({ type: 'signatureV2', signers }));
     return setParserName(apkSigningBlockSignatureV2PairInnerParser, 'apkSigningBlockSignatureV2PairInnerParser');
 };
@@ -43,7 +44,7 @@ const createApkSigningBlockPairInnerParser = (length) => createDisjunctionParser
 const apkSigningBlockPairParser = createUint64LengthPrefixedParser(length => createApkSigningBlockPairInnerParser(Number(length)));
 setParserName(apkSigningBlockPairParser, 'apkSigningBlockPairParser');
 const apkSigningBlockPairsParser = createArrayParser(apkSigningBlockPairParser);
-const apkSigningBlockParser = createUint64LengthPrefixedParser(sizeOfBlock => promiseCompose(createTupleParser([
+export const apkSigningBlockParser = createUint64LengthPrefixedParser(sizeOfBlock => promiseCompose(createTupleParser([
     apkSigningBlockPairsParser,
     uint64LEParser,
     createExactSequenceParser(Buffer.from('APK Sig Block 42', 'utf8')),
@@ -60,56 +61,61 @@ const apkSigningBlockParser = createUint64LengthPrefixedParser(sizeOfBlock => pr
     }));
     return {
         zeroPaddingLength: zeroPaddingPair?.length,
-        signatureV2: signatureV2Pair?.signers,
+        signatureV2: signatureV2Pair ? {
+            signers: signatureV2Pair?.signers,
+        } : undefined,
         pairs: genericPairs,
     };
 }));
-const apkSignatureSchemeV2DigestParser = createUint32LengthPrefixedParser(pairLength => promiseCompose(createTupleParser([
+const apkSignatureV2DigestParser = 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([
+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 })));
-const apkSignatureSchemeV2AdditionalAttributesParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureSchemeV2AdditionalAttributeParser);
-const apkSignatureSchemeV2SignedDataParser = createUint32LengthPrefixedSliceBoundedParser(promiseCompose(createTupleParser([
-    apkSignatureSchemeV2DigestsParser,
-    apkSignatureSchemeV2CertificatesParser,
-    createOptionalParser(apkSignatureSchemeV2AdditionalAttributesParser),
+setParserName(apkSignatureV2AdditionalAttributeParser, 'apkSignatureV2AdditionalAttributeParser');
+const apkSignatureV2AdditionalAttributesParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureV2AdditionalAttributeParser);
+setParserName(apkSignatureV2AdditionalAttributesParser, 'apkSignatureV2AdditionalAttributesParser');
+const apkSignatureV2SignedDataParser = createUint32LengthPrefixedSliceBoundedParser(promiseCompose(createTupleParser([
+    apkSignatureV2DigestsParser,
+    apkSignatureV2CertificatesParser,
+    apkSignatureV2AdditionalAttributesParser,
     createArrayParser(createExactElementParser(0)),
-]), ([digests = [], certificates = [], additionalAttributes = [],]) => ({
+]), ([digests, certificates, additionalAttributes, zeroPadding,]) => ({
     digests,
     certificates,
     additionalAttributes,
+    zeroPaddingLength: zeroPadding.length,
 })));
-setParserName(apkSignatureSchemeV2SignedDataParser, 'apkSignatureSchemeV2SignedDataParser');
-const apkSignatureSchemeV2SignatureParser = createUint32LengthPrefixedParser(signatureLength => promiseCompose(createTupleParser([
+setParserName(apkSignatureV2SignedDataParser, 'apkSignatureV2SignedDataParser');
+const apkSignatureV2SignatureParser = 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]) => ({
+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(apkSignatureSchemeV2SignerParser, 'apkSignatureSchemeV2SignerParser');
-const apkSignatureSchemeV2SignersParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureSchemeV2SignerParser);
-setParserName(apkSignatureSchemeV2SignersParser, 'apkSignatureSchemeV2SignersParser');
+setParserName(apkSignatureV2SignerParser, 'apkSignatureV2SignerParser');
+const apkSignatureV2SignersParser = createUint32LengthPrefixedSliceBoundedArrayParser(apkSignatureV2SignerParser);
+setParserName(apkSignatureV2SignersParser, 'apkSignatureV2SignersParser');
 const apkParser_ = createTupleParser([
     createArrayParser(zipLocalFileParser),
     createOptionalParser(zipArchiveDecryptionHeaderParser),
@@ -133,3 +139,26 @@ export const apkParser = promiseCompose(apkParser_, async ([zipLocalFiles, zipAr
     };
 });
 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,5 +1,5 @@
 import test from 'ava';
-import { uint8ArrayInputCompanion } from './inputCompanion.js';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 import { runParser } from './parser.js';
 import { apkParser } from './apkParser.js';
 for (const apkCid of [
@@ -9,7 +9,7 @@ for (const apkCid of [
     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, {
+        const actual = await runParser(apkParser, apkStream, uint8ArrayParserInputCompanion, {
             errorJoinMode: 'all',
         });
         for (const entry of actual.entries) {

package/build/apkUnparser.d.ts

@@ -0,0 +1,4 @@
+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

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

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

package/build/apkUnparser.test.js

@@ -0,0 +1,26 @@
+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/arbitraryFileSystemEntry.js

@@ -1,5 +1,5 @@
 import * as fc from 'fast-check';
-export const arbitraryFileSystemEntry = fc.letrec((tie) => ({
+export const arbitraryFileSystemEntry = fc.letrec(tie => ({
     entry: fc.oneof(fc.record({
         type: fc.constant('file'),
         name: fc.string(),

package/build/arbitraryZip.d.ts

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

package/build/arbitraryZip.js

@@ -1,8 +1,6 @@
 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;
+import { arbitraryDosDateTime } from './arbitraryDosDateTime.js';
 const arbitraryPath = fc.string({ minLength: 1 }).filter(path => {
     const pathSegments = path.split('/');
     const pathHasEmptySegments = pathSegments.some(segment => segment.length === 0);
@@ -16,7 +14,10 @@ const createArbitraryZipEntry = (platform) => fc.oneof(fc.record({
     path: arbitraryPath,
     date: arbitraryDosDateTime,
     comment: fc.string(),
-    permissions: createArbitraryZipPermissions(platform),
+    hostSystem: fc.constant(platform),
+    attributes: fc.record({
+        directory: fc.constant(false),
+    }),
     compression: fc.oneof(fc.constant('store'), fc.constant('deflate')),
     content: fc.uint8Array(),
 }).filter(zipFileEntry => {
@@ -24,23 +25,16 @@ const createArbitraryZipEntry = (platform) => fc.oneof(fc.record({
         && 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;
+    hostSystem: fc.constant(platform),
+    attributes: fc.record({
+        directory: fc.constant(false),
+    }),
 }));
 const createArbitraryZipEntries = (platform) => (fc
     .array(createArbitraryZipEntry(platform))
@@ -70,10 +64,10 @@ const createArbitraryZipEntries = (platform) => (fc
                     path: directoryPath,
                     date: entry.date,
                     comment: '',
-                    permissions: entry.permissions.type === 'dos' ? {
-                        type: 'dos',
-                        dosPermissions: entry.permissions.dosPermissions | DOS_DIRECTORY_FLAG,
-                    } : entry.permissions,
+                    hostSystem: platform,
+                    attributes: {
+                        directory: true,
+                    },
                 });
                 seenDirectoryPaths.add(directoryPath);
             }

package/build/arbitraryZipPermissions.d.ts

@@ -1,8 +1 @@
-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;
-}>;
+export {};

package/build/arbitraryZipPermissions.js

@@ -1,16 +1 @@
-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;
-};
+export {};

package/build/arbitraryZipStream.d.ts

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

package/build/arbitraryZipStream.js

@@ -4,8 +4,8 @@ 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,
+        // 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, {
@@ -30,7 +30,7 @@ export const arbitraryZipStream = arbitraryZip.map(zip => {
     const zipInternalStream = jsZip.generateInternalStream({
         type: 'uint8array',
         comment: zip.comment,
-        platform: zip.entries.at(0)?.permissions.type.toUpperCase(),
+        platform: zip.entries.at(0)?.hostSystem.toUpperCase(),
     });
     const zipStream = new ReadableStream({
         start(controller) {

package/build/arrayParser.d.ts

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

package/build/arrayParser.js

@@ -1,5 +1,5 @@
-import { getParserName, setParserName } from "./parser.js";
-import { ParserParsingFailedError } from "./parserError.js";
+import { getParserName, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
 export const createArrayParser = (elementParser) => {
     const arrayParser = async (parserContext) => {
         const elements = [];

package/build/arrayParser.test.js

@@ -1,9 +1,9 @@
 import test from 'ava';
 import { createArrayParser } from './arrayParser.js';
 import { runParser } from './parser.js';
-import { stringInputCompanion } from './inputCompanion.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
 test('does not loop forever with a child parser that does not consume anything', async (t) => {
     const parser = createArrayParser(async () => undefined);
-    const result = await runParser(parser, 'foo', stringInputCompanion);
+    const result = await runParser(parser, 'foo', stringParserInputCompanion);
     t.deepEqual(result, []);
 });

package/build/arrayUnparser.d.ts

@@ -0,0 +1,2 @@
+import { Unparser } from "./unparser.js";
+export declare const createArrayUnparser: <ElementInput, Sequence>(elementUnparser: Unparser<ElementInput, Sequence>) => Unparser<ElementInput[], Sequence>;

package/build/arrayUnparser.js

@@ -0,0 +1,8 @@
+export const createArrayUnparser = (elementUnparser) => {
+    const arrayUnparser = async function* (input, unparserContext) {
+        for (const element of input) {
+            yield* elementUnparser(element, unparserContext);
+        }
+    };
+    return arrayUnparser;
+};

package/build/bsonParser.test.js

@@ -3,7 +3,7 @@ import { BSON } from 'bson';
 import { bsonDocumentParser } from './bsonParser.js';
 import { arbitrarilySlicedAsyncIterator } from './arbitrarilySlicedAsyncInterator.js';
 import { runParser } from './parser.js';
-import { uint8ArrayInputCompanion } from './inputCompanion.js';
+import { uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
 testProp('bson', [
     arbitrarilySlicedAsyncIterator(fc
         .json()
@@ -17,7 +17,7 @@ testProp('bson', [
         .map(jsonString => BSON.serialize(JSON.parse(jsonString)))),
 ], async (t, [bsonUint8Array, bsonUint8ArrayChunkIterator]) => {
     const expected = BSON.deserialize(bsonUint8Array);
-    const actual = await runParser(bsonDocumentParser, bsonUint8ArrayChunkIterator, uint8ArrayInputCompanion);
+    const actual = await runParser(bsonDocumentParser, bsonUint8ArrayChunkIterator, uint8ArrayParserInputCompanion);
     t.deepEqual(actual, expected);
 }, {
     verbose: true,

package/build/customInvariant.d.ts

@@ -0,0 +1,4 @@
+import { type Constructor } from 'type-fest';
+export type Falsy = '' | 0 | false | undefined;
+export type ValueOrAccessor<T> = T | (() => T);
+export declare function customInvariant<T>(ErrorConstructor: Constructor<Error, [message: string]> | ((message: string) => Error), value: T, formatOrFormatLines: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;

package/build/customInvariant.js

@@ -0,0 +1,11 @@
+export function customInvariant(ErrorConstructor, value, formatOrFormatLines, ...formatArguments) {
+    if (value) {
+        return value;
+    }
+    let format = typeof formatOrFormatLines === 'function' ? formatOrFormatLines() : formatOrFormatLines;
+    format = Array.isArray(format) ? format.join('\n') : format;
+    throw new ErrorConstructor(format.replaceAll('%s', () => {
+        const argumentOrAccessor = formatArguments.shift();
+        return typeof argumentOrAccessor === 'function' ? argumentOrAccessor() : argumentOrAccessor;
+    }));
+}

package/build/debugLogParser.d.ts

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

package/build/debugLogParser.js

@@ -1,4 +1,4 @@
-import { getParserName, setParserName } from "./parser.js";
+import { getParserName, setParserName } from './parser.js';
 export const createDebugLogParser = (childParser) => {
     let idCounter = 0;
     const debugLogParser = async (parserContext) => {

package/build/elementParser.d.ts

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

package/build/elementParser.js

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

package/build/endOfInputParser.d.ts

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

package/build/exactElementParser.d.ts

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