@futpib/parser 1.0.0 → 1.0.2

package/src/arbitraryZip.ts

@@ -1,10 +1,13 @@
 import * as fc from 'fast-check';
-import { Zip, ZipDirectoryEntry, ZipEntry, ZipFileEntry } from './zip.js';
-import { arbitraryDosDateTime } from './arbitraryDosDateTime.js';
-import { createArbitraryZipPermissions } from './arbitraryZipPermissions.js';
 import invariant from 'invariant';
-
-const DOS_DIRECTORY_FLAG = 0b00010000;
+import {
+	type Zip,
+	type ZipDirectoryEntry,
+	type ZipFileEntry,
+	type ZipEntry,
+	type ZipEntryAttributes,
+} from './zip.js';
+import { arbitraryDosDateTime } from './arbitraryDosDateTime.js';
 
 const arbitraryPath = fc.string({ minLength: 1 }).filter(path => {
 	const pathSegments = path.split('/');
@@ -26,7 +29,10 @@ const createArbitraryZipEntry = (platform: 'unix' | 'dos') => fc.oneof<[
 		path: arbitraryPath,
 		date: arbitraryDosDateTime,
 		comment: fc.string(),
-		permissions: createArbitraryZipPermissions(platform),
+		hostSystem: fc.constant(platform),
+		attributes: fc.record<ZipEntryAttributes>({
+			directory: fc.constant(false),
+		}),
 		compression: fc.oneof(
 			fc.constant('store' as const),
 			fc.constant('deflate' as const),
@@ -40,13 +46,6 @@ const createArbitraryZipEntry = (platform: 'unix' | 'dos') => fc.oneof<[
 			return false;
 		}
 
-		if (
-			zipFileEntry.permissions.type === 'dos'
-				&& zipFileEntry.permissions.dosPermissions & DOS_DIRECTORY_FLAG
-		) {
-			return false;
-		}
-
 		return true;
 	}),
 	fc.record<ZipDirectoryEntry>({
@@ -54,16 +53,10 @@ const createArbitraryZipEntry = (platform: 'unix' | 'dos') => fc.oneof<[
 		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<ZipEntryAttributes>({
+			directory: fc.constant(false),
+		}),
 	}),
 );
 
@@ -106,10 +99,10 @@ const createArbitraryZipEntries = (platform: 'unix' | 'dos') => (
 							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/src/arbitraryZipPermissions.ts

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

package/src/arbitraryZipStream.ts

@@ -1,13 +1,13 @@
 import JSZip from 'jszip';
-import { ZipEntry } from './zip.js';
+import { type ZipEntry } from './zip.js';
 import { arbitraryZip } from './arbitraryZip.js';
 
 function addZipEntryToZip(zip: JSZip, zipEntry: 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') {
@@ -35,7 +35,7 @@ export const arbitraryZipStream = arbitraryZip.map(zip => {
 	const zipInternalStream = jsZip.generateInternalStream({
 		type: 'uint8array',
 		comment: zip.comment,
-		platform: zip.entries.at(0)?.permissions.type.toUpperCase() as any,
+		platform: zip.entries.at(0)?.hostSystem.toUpperCase() as any,
 	});
 
 	const zipStream = new ReadableStream<Uint8Array>({

package/src/arrayParser.test.ts

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

package/src/arrayParser.ts

@@ -1,5 +1,5 @@
-import { getParserName, Parser, setParserName } from "./parser.js";
-import { ParserParsingFailedError } from "./parserError.js";
+import { getParserName, type Parser, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
 
 export const createArrayParser = <ElementOutput, Sequence>(
 	elementParser: Parser<ElementOutput, Sequence>,
@@ -15,6 +15,7 @@ export const createArrayParser = <ElementOutput, Sequence>(
 				if (elementParserContext.position === initialPosition) {
 					return elements;
 				}
+
 				elements.push(element);
 				elementParserContext.unlookahead();
 			} catch (error) {

package/src/arrayUnparser.ts

@@ -0,0 +1,13 @@
+import { Unparser } from "./unparser.js";
+
+export const createArrayUnparser = <ElementInput, Sequence>(
+	elementUnparser: Unparser<ElementInput, Sequence>,
+): Unparser<ElementInput[], Sequence> => {
+	const arrayUnparser: Unparser<ElementInput[], Sequence> = async function * (input, unparserContext) {
+		for (const element of input) {
+			yield * elementUnparser(element, unparserContext);
+		}
+	};
+
+	return arrayUnparser;
+}

package/src/backsmali.ts

@@ -0,0 +1,30 @@
+import fs from 'node:fs/promises';
+import { execa } from 'execa';
+import { temporaryDirectory, temporaryFile } from 'tempy';
+import path from 'node:path';
+
+export async function baksmaliClass(dexStream: AsyncIterable<Uint8Array>, smaliFilePath: string) {
+	const inputFilePath = temporaryFile();
+	const outputDirectoryPath = temporaryDirectory();
+
+	await fs.writeFile(inputFilePath, dexStream);
+
+	await execa('baksmali', [
+		'disassemble',
+		'--classes', 'L' + smaliFilePath + ';',
+		'--output', outputDirectoryPath,
+		inputFilePath,
+	]);
+
+	await fs.unlink(inputFilePath);
+
+	const smaliFilePath_ = path.join(outputDirectoryPath, smaliFilePath + '.smali');
+
+	const smali = await fs.readFile(smaliFilePath_, 'utf8');
+
+	await fs.rm(outputDirectoryPath, {
+		recursive: true,
+	});
+
+	return smali;
+}

package/src/bsonParser.test.ts

@@ -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',
@@ -27,7 +27,7 @@ testProp(
 	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);
 	},

package/src/bsonParser.ts

@@ -1,6 +1,5 @@
 import { type JsonObject, type JsonValue } from 'type-fest';
 import { getParserName, setParserName, type Parser } from './parser.js';
-import { invariantDefined } from './invariantDefined.js';
 import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createTupleParser } from './tupleParser.js';
@@ -30,13 +29,21 @@ const cstringParser: Parser<string, Uint8Array> = promiseCompose(
 		)(),
 		nullByteParser,
 	),
-	([sequence]) => Buffer.from(sequence).toString('utf8'),
+	([ sequence ]) => Buffer.from(sequence).toString('utf8'),
 );
 
 const doubleParser: Parser<number, Uint8Array> = promiseCompose(buffer8Parser, buffer => buffer.readDoubleLE(0));
+
+setParserName(doubleParser, 'doubleParser');
+
 const int32Parser: Parser<number, Uint8Array> = promiseCompose(buffer4Parser, buffer => buffer.readInt32LE(0));
+
+setParserName(int32Parser, 'int32Parser');
+
 const uint32Parser: Parser<number, Uint8Array> = promiseCompose(buffer4Parser, buffer => buffer.readUInt32LE(0));
 
+setParserName(uint32Parser, 'uint32Parser');
+
 const createFixedLengthStringParser = (length: number): Parser<string, Uint8Array> => promiseCompose(
 	createFixedLengthBufferParser(length),
 	buffer => buffer.toString('utf8'),
@@ -47,7 +54,7 @@ const createFixedLengthNullTerminatedStringParser = (lengthWihoutNullTerminator:
 		createFixedLengthStringParser(lengthWihoutNullTerminator),
 		nullByteParser,
 	]),
-	([string]) => string,
+	([ string ]) => string,
 );
 
 const bsonStringParser: Parser<string, Uint8Array> = async parserContext => {
@@ -56,6 +63,8 @@ const bsonStringParser: Parser<string, Uint8Array> = async parserContext => {
 	return createFixedLengthNullTerminatedStringParser(stringSize - 1)(parserContext);
 };
 
+setParserName(bsonStringParser, 'bsonStringParser');
+
 const bsonArrayParser = promiseCompose(
 	createTupleParser([
 		createSkipParser(4),
@@ -64,8 +73,10 @@ const bsonArrayParser = promiseCompose(
 	([ _, elements ]) => elements.map(([ _, value ]) => value),
 );
 
+setParserName(bsonArrayParser, 'bsonArrayParser');
+
 const bsonBooleanParser: Parser<boolean, Uint8Array> = async parserContext => {
-	const booleanValue = invariantDefined(await parserContext.read(0), 'Unexpected end of input');
+	const booleanValue = await parserContext.read(0);
 
 	return booleanValue === 1;
 };
@@ -119,7 +130,7 @@ const bsonElementListParser: Parser<Array<[ string, JsonValue ]>, Uint8Array> =
 		bsonElementParser,
 		nullByteParser,
 	),
-	([elements]) => elements,
+	([ elements ]) => elements,
 );
 
 export const bsonDocumentParser: Parser<JsonObject, Uint8Array> = promiseCompose(

package/src/{parserInvariant.ts → customInvariant.ts}

@@ -4,11 +4,11 @@ export type Falsy = '' | 0 | false | undefined;
 
 export type ValueOrAccessor<T> = T | (() => T);
 
-export function parserInvariant<T>(
+export function customInvariant<T>(
 	ErrorConstructor: Constructor<Error, [message: string]> | ((message: string) => Error),
 	value: T,
 	formatOrFormatLines: ValueOrAccessor<string | string[]>,
-	...formatArguments: any[]
+	...formatArguments: (unknown | (() => unknown))[]
 ): Exclude<T, Falsy> {
 	if (value) {
 		return value as any;