@futpib/parser 1.0.1 → 1.0.3

package/build/arbitraryDalvikExecutable.js

@@ -0,0 +1,282 @@
+import * as fc from 'fast-check';
+// String generators for valid Dalvik identifiers and type descriptors
+const arbitraryJavaIdentifier = fc.stringMatching(/^[a-zA-Z_][a-zA-Z0-9_]*$/);
+const arbitraryPrimitiveType = fc.oneof(fc.constant('V'), // void
+fc.constant('Z'), // boolean
+fc.constant('B'), // byte
+fc.constant('S'), // short
+fc.constant('C'), // char
+fc.constant('I'), // int
+fc.constant('J'), // long
+fc.constant('F'), // float
+fc.constant('D'));
+const arbitraryDalvikClassName = fc.tuple(fc.array(arbitraryJavaIdentifier, { minLength: 1, maxLength: 3 }), arbitraryJavaIdentifier).map(([packages, className]) => `L${packages.join('/')}/${className};`);
+const arbitraryDalvikTypeName = fc.oneof(arbitraryPrimitiveType, arbitraryDalvikClassName, arbitraryPrimitiveType.map(p => `[${p}`), // array of primitive
+arbitraryDalvikClassName.map(c => `[${c}`));
+const arbitraryDalvikMethodName = fc.oneof(arbitraryJavaIdentifier, fc.constant('<init>'), fc.constant('<clinit>'));
+const arbitraryDalvikFieldName = arbitraryJavaIdentifier;
+// Access flags generator - common flags for all contexts
+const arbitraryDalvikExecutableAccessFlagsCommon = fc.record({
+    public: fc.boolean(),
+    private: fc.boolean(),
+    protected: fc.boolean(),
+    static: fc.boolean(),
+    final: fc.boolean(),
+    synchronized: fc.boolean(),
+    volatile: fc.constant(false),
+    bridge: fc.constant(false),
+    transient: fc.constant(false),
+    varargs: fc.constant(false),
+    native: fc.boolean(),
+    interface: fc.boolean(),
+    abstract: fc.boolean(),
+    strict: fc.boolean(),
+    synthetic: fc.boolean(),
+    annotation: fc.boolean(),
+    enum: fc.boolean(),
+    constructor: fc.boolean(),
+    declaredSynchronized: fc.boolean(),
+});
+// Access flags for fields - volatile and transient are valid (0x40 and 0x80)
+const arbitraryDalvikExecutableFieldAccessFlags = fc.record({
+    public: fc.boolean(),
+    private: fc.boolean(),
+    protected: fc.boolean(),
+    static: fc.boolean(),
+    final: fc.boolean(),
+    synchronized: fc.boolean(),
+    volatile: fc.boolean(),
+    bridge: fc.constant(false),
+    transient: fc.boolean(),
+    varargs: fc.constant(false),
+    native: fc.boolean(),
+    interface: fc.boolean(),
+    abstract: fc.boolean(),
+    strict: fc.boolean(),
+    synthetic: fc.boolean(),
+    annotation: fc.boolean(),
+    enum: fc.boolean(),
+    constructor: fc.boolean(),
+    declaredSynchronized: fc.boolean(),
+});
+// Access flags for methods - bridge and varargs are valid (0x40 and 0x80)
+const arbitraryDalvikExecutableMethodAccessFlags = fc.record({
+    public: fc.boolean(),
+    private: fc.boolean(),
+    protected: fc.boolean(),
+    static: fc.boolean(),
+    final: fc.boolean(),
+    synchronized: fc.boolean(),
+    volatile: fc.constant(false),
+    bridge: fc.boolean(),
+    transient: fc.constant(false),
+    varargs: fc.boolean(),
+    native: fc.boolean(),
+    interface: fc.boolean(),
+    abstract: fc.boolean(),
+    strict: fc.boolean(),
+    synthetic: fc.boolean(),
+    annotation: fc.boolean(),
+    enum: fc.boolean(),
+    constructor: fc.boolean(),
+    declaredSynchronized: fc.boolean(),
+});
+// Generic access flags for class-level (uses common)
+const arbitraryDalvikExecutableAccessFlags = arbitraryDalvikExecutableAccessFlagsCommon;
+// Field generator
+const arbitraryDalvikExecutableField = fc.record({
+    class: arbitraryDalvikClassName,
+    type: arbitraryDalvikTypeName,
+    name: arbitraryDalvikFieldName,
+});
+const arbitraryDalvikExecutableFieldWithAccess = fc.record({
+    field: arbitraryDalvikExecutableField,
+    accessFlags: arbitraryDalvikExecutableFieldAccessFlags,
+});
+// Prototype generator
+const arbitraryShorty = fc.tuple(arbitraryPrimitiveType, // return type
+fc.array(fc.oneof(fc.constant('L'), arbitraryPrimitiveType), { maxLength: 5 })).map(([returnType, params]) => returnType + params.join(''));
+const arbitraryDalvikExecutablePrototype = arbitraryShorty.chain(shorty => {
+    const returnTypeChar = shorty[0];
+    const paramChars = shorty.slice(1).split('');
+    const returnType = returnTypeChar === 'L' ? arbitraryDalvikClassName : fc.constant(returnTypeChar);
+    const parameters = fc.tuple(...paramChars.map(char => char === 'L' ? arbitraryDalvikClassName : fc.constant(char)));
+    return fc.record({
+        shorty: fc.constant(shorty),
+        returnType,
+        parameters,
+    });
+});
+// Method generator
+const arbitraryDalvikExecutableMethod = fc.record({
+    class: arbitraryDalvikClassName,
+    prototype: arbitraryDalvikExecutablePrototype,
+    name: arbitraryDalvikMethodName,
+});
+// Encoded value generator (recursive)
+// DalvikExecutableEncodedValue is now a tagged union with type information
+const arbitraryDalvikExecutableEncodedValue = fc.letrec(tie => ({
+    value: fc.oneof(fc.record({ type: fc.constant('byte'), value: fc.integer({ min: -128, max: 127 }) }), fc.record({ type: fc.constant('short'), value: fc.integer({ min: -32768, max: 32767 }) }), fc.record({ type: fc.constant('char'), value: fc.integer({ min: 0, max: 65535 }) }), fc.record({ type: fc.constant('int'), value: fc.integer({ min: -2147483648, max: 2147483647 }) }), fc.record({ type: fc.constant('long'), value: fc.bigInt({ min: -9223372036854775808n, max: 9223372036854775807n }) }), fc.record({ type: fc.constant('float'), value: fc.float() }), fc.record({ type: fc.constant('double'), value: fc.double() }), fc.record({ type: fc.constant('methodType'), value: arbitraryDalvikExecutablePrototype }), fc.record({ type: fc.constant('methodHandle'), value: fc.nat(255) }), fc.record({ type: fc.constant('string'), value: fc.string() }), fc.record({ type: fc.constant('type'), value: arbitraryDalvikClassName }), fc.record({ type: fc.constant('field'), value: arbitraryDalvikExecutableField }), fc.record({ type: fc.constant('method'), value: arbitraryDalvikExecutableMethod }), fc.record({ type: fc.constant('enum'), value: arbitraryDalvikExecutableField }), fc.record({ type: fc.constant('array'), value: fc.array(tie('value'), { maxLength: 3 }) }), 
+    // Note: We skip 'annotation' type here to avoid deep recursion complexity
+    fc.record({ type: fc.constant('null'), value: fc.constant(null) }), fc.record({ type: fc.constant('boolean'), value: fc.boolean() })),
+})).value;
+// Annotation generators
+const arbitraryAnnotationVisibility = fc.oneof(fc.constant('build'), fc.constant('runtime'), fc.constant('system'));
+const arbitraryDalvikExecutableAnnotationElement = fc.record({
+    name: arbitraryJavaIdentifier,
+    value: arbitraryDalvikExecutableEncodedValue,
+});
+const arbitraryDalvikExecutableAnnotation = fc.record({
+    visibility: arbitraryAnnotationVisibility,
+    type: arbitraryDalvikClassName,
+    elements: fc.array(arbitraryDalvikExecutableAnnotationElement, { maxLength: 3 }),
+});
+// Debug info generators
+const arbitraryDalvikExecutableDebugByteCodeValue = fc.oneof(fc.record({
+    type: fc.constant('advancePc'),
+    addressDiff: fc.nat({ max: 255 }),
+}), fc.record({
+    type: fc.constant('advanceLine'),
+    lineDiff: fc.integer({ min: -128, max: 127 }),
+}), fc.record({
+    type: fc.constant('startLocal'),
+    registerNum: fc.nat({ max: 255 }),
+    name: fc.option(arbitraryJavaIdentifier, { nil: undefined }),
+    type_: fc.option(arbitraryDalvikTypeName, { nil: undefined }),
+}), fc.record({
+    type: fc.constant('startLocalExtended'),
+    registerNum: fc.nat({ max: 255 }),
+    name: fc.option(arbitraryJavaIdentifier, { nil: undefined }),
+    type_: fc.option(arbitraryDalvikTypeName, { nil: undefined }),
+    signature: fc.option(fc.string(), { nil: undefined }),
+}), fc.record({
+    type: fc.constant('endLocal'),
+    registerNum: fc.nat({ max: 255 }),
+}), fc.record({
+    type: fc.constant('restartLocal'),
+    registerNum: fc.nat({ max: 255 }),
+}), fc.record({
+    type: fc.constant('setPrologueEnd'),
+}), fc.record({
+    type: fc.constant('setEpilogueBegin'),
+}), fc.record({
+    type: fc.constant('setFile'),
+    name: fc.option(fc.string(), { nil: undefined }),
+}), fc.record({
+    type: fc.constant('special'),
+    // Special opcodes must be >= 0x0A (values 0x00-0x09 are specific debug opcodes)
+    value: fc.integer({ min: 0x0A, max: 255 }),
+}));
+const arbitraryDalvikExecutableDebugInfo = fc.record({
+    lineStart: fc.nat({ max: 65535 }),
+    parameterNames: fc.array(fc.option(arbitraryJavaIdentifier, { nil: undefined }), { maxLength: 5 }),
+    bytecode: fc.array(arbitraryDalvikExecutableDebugByteCodeValue, { maxLength: 10 }),
+});
+const arbitraryDalvikExecutableEncodedTypeAddressPair = fc.record({
+    type: arbitraryDalvikClassName,
+    address: fc.nat({ max: 65535 }),
+});
+const arbitraryDalvikExecutableEncodedCatchHandler = fc.record({
+    handlers: fc.array(arbitraryDalvikExecutableEncodedTypeAddressPair, { maxLength: 3 }),
+    catchAllAddress: fc.option(fc.nat({ max: 65535 }), { nil: undefined }),
+}).filter(handler => {
+    // A handler must have at least one typed handler OR a catch-all address
+    return handler.handlers.length > 0 || handler.catchAllAddress !== undefined;
+});
+const arbitraryDalvikExecutableTry = fc.record({
+    startAddress: fc.nat({ max: 65535 }),
+    instructionCount: fc.nat({ max: 255 }),
+    handler: arbitraryDalvikExecutableEncodedCatchHandler,
+});
+// Generic factory function for DalvikExecutable
+export const createArbitraryDalvikExecutable = (arbitraryInstructions) => {
+    // Code generator using provided instructions arbitrary
+    const arbitraryDalvikExecutableCode = fc.record({
+        registersSize: fc.nat({ max: 65535 }),
+        insSize: fc.nat({ max: 255 }),
+        outsSize: fc.nat({ max: 255 }),
+        debugInfo: fc.option(arbitraryDalvikExecutableDebugInfo, { nil: undefined }),
+        instructions: arbitraryInstructions,
+        tries: fc.array(arbitraryDalvikExecutableTry, { maxLength: 2 }),
+    });
+    // Method with access and code
+    const arbitraryDalvikExecutableMethodWithAccess = fc.record({
+        method: arbitraryDalvikExecutableMethod,
+        accessFlags: arbitraryDalvikExecutableMethodAccessFlags,
+        code: fc.option(arbitraryDalvikExecutableCode, { nil: undefined }),
+    });
+    // Annotation collections
+    const arbitraryDalvikExecutableClassFieldAnnotation = fc.record({
+        field: arbitraryDalvikExecutableField,
+        annotations: fc.option(fc.array(arbitraryDalvikExecutableAnnotation, { maxLength: 2 }), { nil: undefined }),
+    });
+    const arbitraryDalvikExecutableClassMethodAnnotation = fc.record({
+        method: arbitraryDalvikExecutableMethod,
+        annotations: fc.array(arbitraryDalvikExecutableAnnotation, { maxLength: 2 }),
+    });
+    const arbitraryDalvikExecutableClassParameterAnnotation = fc.record({
+        method: arbitraryDalvikExecutableMethod,
+        annotations: fc.array(fc.array(arbitraryDalvikExecutableAnnotation, { maxLength: 2 }), { maxLength: 3 }),
+    });
+    const arbitraryDalvikExecutableClassAnnotations = fc.record({
+        classAnnotations: fc.array(arbitraryDalvikExecutableAnnotation, { maxLength: 2 }),
+        fieldAnnotations: fc.array(arbitraryDalvikExecutableClassFieldAnnotation, { maxLength: 2 }),
+        methodAnnotations: fc.array(arbitraryDalvikExecutableClassMethodAnnotation, { maxLength: 2 }),
+        parameterAnnotations: fc.array(arbitraryDalvikExecutableClassParameterAnnotation, { maxLength: 2 }),
+    }).map(annotations => ({
+        ...annotations,
+        // Filter out field/method/parameter annotations with undefined or empty annotations array
+        // In DEX format, fields/methods/parameters with no annotations should not appear in the annotations directory at all
+        fieldAnnotations: annotations.fieldAnnotations.filter(fa => fa.annotations !== undefined && fa.annotations.length > 0),
+        methodAnnotations: annotations.methodAnnotations.filter(ma => ma.annotations.length > 0),
+        parameterAnnotations: annotations.parameterAnnotations.filter(pa => pa.annotations.length > 0 && pa.annotations.some(paramAnnots => paramAnnots.length > 0)),
+    }));
+    // Class data
+    const arbitraryDalvikExecutableClassData = fc.record({
+        staticFields: fc.array(arbitraryDalvikExecutableFieldWithAccess, { maxLength: 3 }),
+        instanceFields: fc.array(arbitraryDalvikExecutableFieldWithAccess, { maxLength: 3 }),
+        directMethods: fc.array(arbitraryDalvikExecutableMethodWithAccess, { maxLength: 3 }),
+        virtualMethods: fc.array(arbitraryDalvikExecutableMethodWithAccess, { maxLength: 3 }),
+    }).filter(classData => 
+    // Filter out empty classData (all arrays empty) as it's semantically equivalent to undefined
+    classData.staticFields.length > 0 ||
+        classData.instanceFields.length > 0 ||
+        classData.directMethods.length > 0 ||
+        classData.virtualMethods.length > 0);
+    // Class definition
+    const arbitraryDalvikExecutableClassDefinition = fc.record({
+        class: arbitraryDalvikClassName,
+        accessFlags: arbitraryDalvikExecutableAccessFlags,
+        superclass: arbitraryDalvikClassName,
+        interfaces: fc.array(arbitraryDalvikClassName, { maxLength: 3 }),
+        sourceFile: fc.option(fc.stringMatching(/^[a-zA-Z0-9_]+\.java$/), { nil: undefined }),
+        annotations: fc.option(arbitraryDalvikExecutableClassAnnotations, { nil: undefined }),
+        staticValues: fc.array(arbitraryDalvikExecutableEncodedValue, { maxLength: 3 }),
+        classData: fc.option(arbitraryDalvikExecutableClassData, { nil: undefined }),
+    }).map(classDef => {
+        // Match parser logic: if all members are synthetic, set class synthetic to true
+        const allMembers = [
+            ...classDef.classData?.staticFields ?? [],
+            ...classDef.classData?.instanceFields ?? [],
+            ...classDef.classData?.directMethods ?? [],
+            // Note: virtualMethods are not included to match parser behavior
+        ];
+        const allMembersAreSynthetic = (allMembers.every(member => member.accessFlags.synthetic)
+            && allMembers.length > 0);
+        if (allMembersAreSynthetic) {
+            return {
+                ...classDef,
+                accessFlags: {
+                    ...classDef.accessFlags,
+                    synthetic: true,
+                },
+            };
+        }
+        return classDef;
+    });
+    // Root DalvikExecutable
+    return fc.record({
+        classDefinitions: fc.array(arbitraryDalvikExecutableClassDefinition, { minLength: 1, maxLength: 3 }),
+        link: fc.option(fc.uint8Array({ minLength: 1, maxLength: 10 }), { nil: undefined }),
+    });
+};

package/build/arbitraryDosDateTime.js

@@ -2,6 +2,7 @@ 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)),
+    noInvalidDate: true,
 }).map(date => {
     date.setSeconds(0);
     date.setMilliseconds(0);

package/build/arbitraryZipStream.js

@@ -4,7 +4,7 @@ function addZipEntryToZip(zip, zipEntry) {
     const options = {
         comment: zipEntry.comment,
         date: zipEntry.date,
-        // unixPermissions: zipEntry.permissions.type === 'unix' ? zipEntry.permissions.unixPermissions : undefined,
+        // UnixPermissions: zipEntry.permissions.type === 'unix' ? zipEntry.permissions.unixPermissions : undefined,
         // dosPermissions: zipEntry.permissions.type === 'dos' ? zipEntry.permissions.dosPermissions : undefined,
     };
     if (zipEntry.type === 'file') {

package/build/arrayParser.js

@@ -1,5 +1,5 @@
 import { getParserName, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError } from './parserError.js';
 export const createArrayParser = (elementParser) => {
     const arrayParser = async (parserContext) => {
         const elements = [];
@@ -15,7 +15,7 @@ export const createArrayParser = (elementParser) => {
                 elementParserContext.unlookahead();
             }
             catch (error) {
-                if (error instanceof ParserParsingFailedError) {
+                if (isParserParsingFailedError(error)) {
                     return elements;
                 }
                 throw error;

package/build/arrayParser.test.js

@@ -1,9 +1,9 @@
 import test from 'ava';
 import { createArrayParser } from './arrayParser.js';
-import { runParser } from './parser.js';
+import { 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 = createArrayParser(async () => undefined);
-    const result = await runParser(parser, 'foo', stringParserInputCompanion);
-    t.deepEqual(result, []);
+    const { output } = await runParserWithRemainingInput(parser, 'foo', stringParserInputCompanion);
+    t.deepEqual(output, []);
 });

package/build/arrayUnparser.d.ts

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

package/build/backsmali.d.ts

@@ -0,0 +1,3 @@
+export declare function baksmaliClass(dexStream: Uint8Array | AsyncIterable<Uint8Array>, smaliFilePath: string): Promise<string>;
+export declare function backsmaliSmaliIsolateClass(dexStream: Uint8Array | AsyncIterable<Uint8Array>, smaliFilePath: string): Promise<Uint8Array>;
+export declare function baksmaliListClasses(dexStream: Uint8Array | AsyncIterable<Uint8Array>): Promise<string[]>;

package/build/backsmali.js

@@ -0,0 +1,50 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execa } from 'execa';
+import { temporaryDirectory, temporaryFile } from 'tempy';
+import { smaliClass } from './smali.js';
+export async function baksmaliClass(dexStream, smaliFilePath) {
+    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;
+}
+export async function backsmaliSmaliIsolateClass(dexStream, smaliFilePath) {
+    const smali = await baksmaliClass(dexStream, smaliFilePath);
+    return smaliClass(smali);
+}
+export async function baksmaliListClasses(dexStream) {
+    const inputFilePath = temporaryFile();
+    await fs.writeFile(inputFilePath, dexStream);
+    const result = await execa('baksmali', [
+        'list',
+        'classes',
+        inputFilePath,
+    ]);
+    await fs.unlink(inputFilePath);
+    if (result.stderr) {
+        throw new Error(`baksmali error: ${result.stderr}`);
+    }
+    const classes = result.stdout
+        .split('\n')
+        .filter(line => line.trim())
+        .map(line => line.trim())
+        .map(class_ => (class_
+        .replace(/^L/, '')
+        .replace(/;$/, '')));
+    return classes;
+}

package/build/bsonParser.js

@@ -1,5 +1,4 @@
 import { getParserName, setParserName } from './parser.js';
-import { invariantDefined } from './invariantDefined.js';
 import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createTupleParser } from './tupleParser.js';
@@ -18,8 +17,11 @@ const elementParser = createElementParser();
 const nullByteParser = createExactElementParser(0);
 const cstringParser = promiseCompose(createTerminatedArrayParser(parserCreatorCompose(() => elementParser, (byte) => async (parserContext) => parserContext.invariant(byte, 'Expected non-null byte'))(), nullByteParser), ([sequence]) => Buffer.from(sequence).toString('utf8'));
 const doubleParser = promiseCompose(buffer8Parser, buffer => buffer.readDoubleLE(0));
+setParserName(doubleParser, 'doubleParser');
 const int32Parser = promiseCompose(buffer4Parser, buffer => buffer.readInt32LE(0));
+setParserName(int32Parser, 'int32Parser');
 const uint32Parser = promiseCompose(buffer4Parser, buffer => buffer.readUInt32LE(0));
+setParserName(uint32Parser, 'uint32Parser');
 const createFixedLengthStringParser = (length) => promiseCompose(createFixedLengthBufferParser(length), buffer => buffer.toString('utf8'));
 const createFixedLengthNullTerminatedStringParser = (lengthWihoutNullTerminator) => promiseCompose(createTupleParser([
     createFixedLengthStringParser(lengthWihoutNullTerminator),
@@ -29,12 +31,14 @@ const bsonStringParser = async (parserContext) => {
     const stringSize = await uint32Parser(parserContext);
     return createFixedLengthNullTerminatedStringParser(stringSize - 1)(parserContext);
 };
+setParserName(bsonStringParser, 'bsonStringParser');
 const bsonArrayParser = promiseCompose(createTupleParser([
     createSkipParser(4),
     createParserAccessorParser(() => bsonElementListParser),
 ]), ([_, elements]) => elements.map(([_, value]) => value));
+setParserName(bsonArrayParser, 'bsonArrayParser');
 const bsonBooleanParser = async (parserContext) => {
-    const booleanValue = invariantDefined(await parserContext.read(0), 'Unexpected end of input');
+    const booleanValue = await parserContext.read(0);
     return booleanValue === 1;
 };
 const int8Parser = promiseCompose(buffer1Parser, buffer => buffer.readInt8(0));

package/build/customInvariant.d.ts

@@ -1,4 +1,5 @@
 import { type Constructor } from 'type-fest';
+import { LazyMessage, LazyMessageError } from './lazyMessageError.js';
 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>;
+export declare function customInvariant<T>(ErrorConstructor: Constructor<LazyMessageError, [LazyMessage]> | ((lazyMessage: LazyMessage) => LazyMessageError), value: T, formatOrFormatLines: ValueOrAccessor<string | string[]>, ...formatArguments: Array<unknown | (() => unknown)>): Exclude<T, Falsy>;

package/build/customInvariant.js

@@ -2,10 +2,8 @@ export function customInvariant(ErrorConstructor, value, formatOrFormatLines, ..
     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;
-    }));
+    throw new ErrorConstructor([
+        formatOrFormatLines,
+        ...formatArguments,
+    ]);
 }

package/build/dalvikBytecodeParser/formatParsers.d.ts

@@ -0,0 +1,171 @@
+import { type Iso } from 'monocle-ts';
+import { type Parser } from '../parser.js';
+export declare const nibblesParser: Parser<[number, number], Uint8Array>;
+type DalvikBytecodeFormat10t = {
+    branchOffset: number;
+};
+export declare const dalvikBytecodeFormat10tParser: Parser<DalvikBytecodeFormat10t, Uint8Array>;
+type DalvikBytecodeFormat10x = void;
+export declare const dalvikBytecodeFormat10xParser: Parser<DalvikBytecodeFormat10x, Uint8Array>;
+type DalvikBytecodeFormat11x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat11xParser: Parser<DalvikBytecodeFormat11x, Uint8Array>;
+type DalvikBytecodeFormat11n = {
+    value: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat11nParser: Parser<DalvikBytecodeFormat11n, Uint8Array>;
+type DalvikBytecodeFormat12x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat12xParser: Parser<DalvikBytecodeFormat12x, Uint8Array>;
+type DalvikBytecodeFormat20t = {
+    branchOffset: number;
+};
+export declare const dalvikBytecodeFormat20tParser: Parser<DalvikBytecodeFormat20t, Uint8Array>;
+type DalvikBytecodeFormat21c<Index> = {
+    index: Index;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat21cParser: <Index>({ isoIndex, }: {
+    isoIndex: Iso<Index, number>;
+}) => Parser<DalvikBytecodeFormat21c<Index>, Uint8Array>;
+type DalvikBytecodeFormat21h = {
+    value: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat21hParser: Parser<DalvikBytecodeFormat21h, Uint8Array>;
+type DalvikBytecodeFormat21t = {
+    branchOffset: number;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat21tParser: () => Parser<DalvikBytecodeFormat21t, Uint8Array>;
+type DalvikBytecodeFormat21s = {
+    registers: number[];
+    value: number;
+};
+export declare const createDalvikBytecodeFormat21sParser: () => Parser<DalvikBytecodeFormat21s, Uint8Array>;
+type DalvikBytecodeFormat22b = {
+    registers: number[];
+    value: number;
+};
+export declare const createDalvikBytecodeFormat22bParser: () => Parser<DalvikBytecodeFormat22b, Uint8Array>;
+type DalvikBytecodeFormat22c<Index> = {
+    registers: number[];
+    index: Index;
+};
+export declare const createDalvikBytecodeFormat22cParser: <Index>({ isoIndex, }: {
+    isoIndex: Iso<Index, number>;
+}) => Parser<DalvikBytecodeFormat22c<Index>, Uint8Array>;
+type DalvikBytecodeFormat22s = {
+    value: number;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat22sParser: () => Parser<DalvikBytecodeFormat22s, Uint8Array>;
+type DalvikBytecodeFormat22t = {
+    branchOffset: number;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat22tParser: () => Parser<DalvikBytecodeFormat22t, Uint8Array>;
+type DalvikBytecodeFormat22x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat22xParser: Parser<DalvikBytecodeFormat22x, Uint8Array>;
+type DalvikBytecodeFormat23x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat23xParser: Parser<DalvikBytecodeFormat23x, Uint8Array>;
+type DalvikBytecodeFormat30t = {
+    branchOffset: number;
+};
+export declare const dalvikBytecodeFormat30tParser: Parser<DalvikBytecodeFormat30t, Uint8Array>;
+type DalvikBytecodeFormat31i = {
+    value: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat31iParser: Parser<DalvikBytecodeFormat31i, Uint8Array>;
+type DalvikBytecodeFormat31c<Index> = {
+    index: Index;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat31cParser: <Index>({ isoIndex, }: {
+    isoIndex: Iso<Index, number>;
+}) => Parser<DalvikBytecodeFormat31c<Index>, Uint8Array>;
+type DalvikBytecodeFormat31t = {
+    branchOffset: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat31tParser: Parser<DalvikBytecodeFormat31t, Uint8Array>;
+type DalvikBytecodeFormat32x = {
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat32xParser: Parser<DalvikBytecodeFormat32x, Uint8Array>;
+type DalvikBytecodeFormat35c<Index> = {
+    index: Index;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat35cParser: <Index>({ isoIndex, }: {
+    isoIndex: Iso<Index, number>;
+}) => Parser<DalvikBytecodeFormat35c<Index>, Uint8Array>;
+type DalvikBytecodeFormat3rc<Index> = {
+    index: Index;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat3rcParser: <Index>({ isoIndex, }: {
+    isoIndex: Iso<Index, number>;
+}) => Parser<DalvikBytecodeFormat3rc<Index>, Uint8Array>;
+type DalvikBytecodeFormat51l = {
+    value: bigint;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat51lParser: Parser<DalvikBytecodeFormat51l, Uint8Array>;
+type DalvikBytecodeFormat20bc = {
+    kind: number;
+    index: number;
+};
+export declare const dalvikBytecodeFormat20bcParser: Parser<DalvikBytecodeFormat20bc, Uint8Array>;
+type DalvikBytecodeFormat22cs = {
+    registers: number[];
+    fieldOffset: number;
+};
+export declare const dalvikBytecodeFormat22csParser: Parser<DalvikBytecodeFormat22cs, Uint8Array>;
+type DalvikBytecodeFormat35mi = {
+    inlineIndex: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat35miParser: Parser<DalvikBytecodeFormat35mi, Uint8Array>;
+type DalvikBytecodeFormat35ms = {
+    vtableOffset: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat35msParser: Parser<DalvikBytecodeFormat35ms, Uint8Array>;
+type DalvikBytecodeFormat3rmi = {
+    inlineIndex: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat3rmiParser: Parser<DalvikBytecodeFormat3rmi, Uint8Array>;
+type DalvikBytecodeFormat3rms = {
+    vtableOffset: number;
+    registers: number[];
+};
+export declare const dalvikBytecodeFormat3rmsParser: Parser<DalvikBytecodeFormat3rms, Uint8Array>;
+type DalvikBytecodeFormat45cc<MethodIndex, ProtoIndex> = {
+    methodIndex: MethodIndex;
+    protoIndex: ProtoIndex;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat45ccParser: <MethodIndex, ProtoIndex>({ isoMethodIndex, isoProtoIndex, }: {
+    isoMethodIndex: Iso<MethodIndex, number>;
+    isoProtoIndex: Iso<ProtoIndex, number>;
+}) => Parser<DalvikBytecodeFormat45cc<MethodIndex, ProtoIndex>, Uint8Array>;
+type DalvikBytecodeFormat4rcc<MethodIndex, ProtoIndex> = {
+    methodIndex: MethodIndex;
+    protoIndex: ProtoIndex;
+    registers: number[];
+};
+export declare const createDalvikBytecodeFormat4rccParser: <MethodIndex, ProtoIndex>({ isoMethodIndex, isoProtoIndex, }: {
+    isoMethodIndex: Iso<MethodIndex, number>;
+    isoProtoIndex: Iso<ProtoIndex, number>;
+}) => Parser<DalvikBytecodeFormat4rcc<MethodIndex, ProtoIndex>, Uint8Array>;
+export {};