@futpib/parser 1.0.2 → 1.0.3

package/build/parserError.js

@@ -1,61 +1,106 @@
-export class ParserError extends Error {
-    name = 'ParserError';
-    position = undefined;
-    inputReaderSate = undefined;
+import { NormalLazyMessageError, NoStackCaptureOverheadLazyMessageError } from './lazyMessageError.js';
+export function isParserError(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && value instanceof Error
+        && 'position' in value
+        && (typeof value.position === 'number' || value.position === undefined)
+        && 'inputReaderSate' in value
+        && (value.inputReaderSate === undefined || typeof value.inputReaderSate === 'object'));
 }
-export class ParserImplementationError extends ParserError {
-    name = 'ParserImplementationError';
+export function isParserParsingFailedError(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && value instanceof Error
+        && 'depth' in value
+        && typeof value.depth === 'number'
+        && 'position' in value
+        && typeof value.position === 'number');
 }
-export class ParserImplementationInvariantError extends ParserImplementationError {
-    name = 'ParserImplementationInvariantError';
+export function isParserParsingJoinError(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && value instanceof Error
+        && 'childErrors' in value
+        && Array.isArray(value.childErrors)
+        && value.childErrors.every((childError) => isParserParsingFailedError(childError)));
 }
-export class ParserParsingFailedError extends ParserError {
-    depth;
-    position;
-    name = 'ParserParsingFailedError';
-    constructor(message, depth, position) {
-        super(message);
-        this.depth = depth;
-        this.position = position;
+function createParserErrorModule(BaseLazyMessageError) {
+    class ParserError extends BaseLazyMessageError {
+        name = 'ParserError';
+        position = undefined;
+        inputReaderSate = undefined;
     }
-}
-export class ParserParsingJoinError extends ParserParsingFailedError {
-    name = 'ParserParsingJoinError';
-    childErrors = [];
-}
-export class ParserParsingJoinNoneError extends ParserParsingJoinError {
-    name = 'ParserParsingJoinNoneError';
-}
-export class ParserParsingJoinAllError extends ParserParsingJoinError {
-    childErrors;
-    name = 'ParserParsingJoinAllError';
-    constructor(message, depth, position, childErrors) {
-        super(message, depth, position);
-        this.childErrors = childErrors;
+    class ParserImplementationError extends ParserError {
+        name = 'ParserImplementationError';
     }
-}
-export class ParserParsingJoinDeepestError extends ParserParsingJoinError {
-    childErrors;
-    name = 'ParserParsingJoinDeepestError';
-    constructor(message, depth, position, childErrors) {
-        super(message, depth, position);
-        this.childErrors = childErrors;
+    class ParserImplementationInvariantError extends ParserImplementationError {
+        name = 'ParserImplementationInvariantError';
     }
-}
-export class ParserParsingJoinFurthestError extends ParserParsingJoinError {
-    childErrors;
-    name = 'ParserParsingJoinFurthestError';
-    constructor(message, depth, position, childErrors) {
-        super(message, depth, position);
-        this.childErrors = childErrors;
+    class ParserParsingFailedError extends ParserError {
+        depth;
+        position;
+        name = 'ParserParsingFailedError';
+        constructor(message, depth, position) {
+            super(message);
+            this.depth = depth;
+            this.position = position;
+        }
     }
+    class ParserParsingJoinError extends ParserParsingFailedError {
+        name = 'ParserParsingJoinError';
+        childErrors = [];
+    }
+    class ParserParsingJoinNoneError extends ParserParsingJoinError {
+        name = 'ParserParsingJoinNoneError';
+    }
+    class ParserParsingJoinAllError extends ParserParsingJoinError {
+        childErrors;
+        name = 'ParserParsingJoinAllError';
+        constructor(message, depth, position, childErrors) {
+            super(message, depth, position);
+            this.childErrors = childErrors;
+        }
+    }
+    class ParserParsingJoinDeepestError extends ParserParsingJoinError {
+        childErrors;
+        name = 'ParserParsingJoinDeepestError';
+        constructor(message, depth, position, childErrors) {
+            super(message, depth, position);
+            this.childErrors = childErrors;
+        }
+    }
+    class ParserParsingJoinFurthestError extends ParserParsingJoinError {
+        childErrors;
+        name = 'ParserParsingJoinFurthestError';
+        constructor(message, depth, position, childErrors) {
+            super(message, depth, position);
+            this.childErrors = childErrors;
+        }
+    }
+    class ParserParsingInvariantError extends ParserParsingFailedError {
+        name = 'ParserParsingInvariantError';
+    }
+    class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
+        name = 'ParserUnexpectedEndOfInputError';
+    }
+    class ParserUnexpectedRemainingInputError extends ParserParsingFailedError {
+        name = 'ParserUnexpectedRemainingInputError';
+    }
+    return {
+        ParserError,
+        ParserImplementationError,
+        ParserImplementationInvariantError,
+        ParserParsingFailedError,
+        ParserParsingJoinError,
+        ParserParsingJoinNoneError,
+        ParserParsingJoinAllError,
+        ParserParsingJoinDeepestError,
+        ParserParsingJoinFurthestError,
+        ParserParsingInvariantError,
+        ParserUnexpectedEndOfInputError,
+        ParserUnexpectedRemainingInputError,
+    };
 }
-export class ParserParsingInvariantError extends ParserParsingFailedError {
-    name = 'ParserParsingInvariantError';
-}
-export class ParserUnexpectedEndOfInputError extends ParserParsingFailedError {
-    name = 'ParserUnexpectedEndOfInputError';
-}
-export class ParserUnexpectedRemainingInputError extends ParserParsingFailedError {
-    name = 'ParserUnexpectedRemainingInputError';
-}
+export const normalParserErrorModule = createParserErrorModule(NormalLazyMessageError);
+export const noStackCaptureOverheadParserErrorModule = createParserErrorModule(NoStackCaptureOverheadLazyMessageError);

package/build/parserImplementationInvariant.d.ts

@@ -1,2 +1,2 @@
 import { type Falsy, type ValueOrAccessor } from './customInvariant.js';
-export declare function parserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: any[]): Exclude<T, Falsy>;
+export declare function parserImplementationInvariant<T>(value: T, format: ValueOrAccessor<string | string[]>, ...formatArguments: unknown[]): Exclude<T, Falsy>;

package/build/parserImplementationInvariant.js

@@ -1,5 +1,5 @@
-import { ParserImplementationInvariantError } from './parserError.js';
 import { customInvariant } from './customInvariant.js';
+import { normalParserErrorModule } from './parserError.js';
 export function parserImplementationInvariant(value, format, ...formatArguments) {
-    return customInvariant(ParserImplementationInvariantError, value, format, ...formatArguments);
+    return customInvariant(normalParserErrorModule.ParserImplementationInvariantError, value, format, ...formatArguments);
 }

package/build/parserInputCompanion.js

@@ -57,8 +57,8 @@ export class Uint8ArrayParserInputCompanion {
         if (sequenceA.length !== sequenceB.length) {
             return false;
         }
-        for (let index = 0; index < sequenceA.length; index++) {
-            if (sequenceA[index] !== sequenceB[index]) {
+        for (const [index, element] of sequenceA.entries()) {
+            if (element !== sequenceB[index]) {
                 return false;
             }
         }

package/build/promiseCompose.js

@@ -1,12 +1,11 @@
 export function promiseCompose(f1, f2) {
-    function promiseComposed(a) {
+    async function promiseComposed(a) {
         const bOrBPromise = f1(a);
         if (bOrBPromise instanceof Promise) {
             return bOrBPromise.then(f2);
         }
         return f2(bOrBPromise);
     }
-    ;
     Object.defineProperty(promiseComposed, 'name', {
         value: `promiseCompose(${f1.name}, ${f2.name})`,
     });

package/build/separatedArrayParser.js

@@ -1,5 +1,5 @@
 import { getParserName, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError } from './parserError.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createTupleParser } from './tupleParser.js';
 export const createSeparatedArrayParser = (elementParser, separatorParser) => {
@@ -22,7 +22,7 @@ export const createSeparatedArrayParser = (elementParser, separatorParser) => {
                 elementParserContext.unlookahead();
             }
             catch (error) {
-                if (error instanceof ParserParsingFailedError) {
+                if (isParserParsingFailedError(error)) {
                     break;
                 }
                 throw error;

package/build/separatedNonEmptyArrayParser.d.ts

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

package/build/separatedNonEmptyArrayParser.js

@@ -0,0 +1,40 @@
+import { getParserName, setParserName } from './parser.js';
+import { isParserParsingFailedError } from './parserError.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+export const createSeparatedNonEmptyArrayParser = (elementParser, separatorParser) => {
+    const separatorThenElementParser = promiseCompose(createTupleParser([
+        separatorParser,
+        elementParser,
+    ]), ([, element]) => element);
+    const separatedNonEmptyArrayParser = async (parserContext) => {
+        let parser = elementParser;
+        const elements = [];
+        while (true) {
+            const elementParserContext = parserContext.lookahead();
+            const initialPosition = elementParserContext.position;
+            try {
+                const element = await parser(elementParserContext);
+                if (elementParserContext.position === initialPosition) {
+                    break;
+                }
+                elements.push(element);
+                elementParserContext.unlookahead();
+            }
+            catch (error) {
+                if (isParserParsingFailedError(error)) {
+                    break;
+                }
+                throw error;
+            }
+            finally {
+                elementParserContext.dispose();
+            }
+            parser = separatorThenElementParser;
+        }
+        parserContext.invariant(elements.length > 0, 'Expected elementParser (%s) to match at least once', getParserName(elementParser, 'anonymousSeparatedNonEmptyArrayChild'));
+        return elements;
+    };
+    setParserName(separatedNonEmptyArrayParser, getParserName(elementParser, 'anonymousSeparatedNonEmptyArrayChild') + '+');
+    return separatedNonEmptyArrayParser;
+};

package/build/separatedNonEmptyArrayParser.test.d.ts

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

package/build/separatedNonEmptyArrayParser.test.js

@@ -0,0 +1,66 @@
+import test from 'ava';
+import { testProp, fc } from '@fast-check/ava';
+import { createSeparatedNonEmptyArrayParser } from './separatedNonEmptyArrayParser.js';
+import { runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { stringFromAsyncIterable } from './stringFromAsyncIterable.js';
+test('empty input throws error', async (t) => {
+    const parser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('element'), createExactSequenceParser(','));
+    await t.throwsAsync(async () => runParser(parser, '', stringParserInputCompanion), {
+        any: true,
+        message: /Expected .* to match at least once/,
+    });
+});
+test('single element without separator matches', async (t) => {
+    const parser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('element'), createExactSequenceParser(','));
+    const result = await runParser(parser, 'element', stringParserInputCompanion);
+    t.deepEqual(result, ['element']);
+});
+test('two elements with separator matches', async (t) => {
+    const parser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('element'), createExactSequenceParser(','));
+    const result = await runParser(parser, 'element,element', stringParserInputCompanion);
+    t.deepEqual(result, ['element', 'element']);
+});
+test('multiple elements with separator matches', async (t) => {
+    const parser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('a'), createExactSequenceParser(','));
+    const result = await runParser(parser, 'a,a,a,a', stringParserInputCompanion);
+    t.deepEqual(result, ['a', 'a', 'a', 'a']);
+});
+test('does not consume trailing separator', async (t) => {
+    const parser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('element'), createExactSequenceParser(','));
+    const { output, remainingInput } = await runParserWithRemainingInput(parser, 'element,element,', stringParserInputCompanion);
+    t.deepEqual(output, ['element', 'element']);
+    t.is(await stringFromAsyncIterable(remainingInput), ',');
+});
+test('does not loop forever with a child parser that does not consume anything', async (t) => {
+    const parser = createSeparatedNonEmptyArrayParser(async () => undefined, () => undefined);
+    await t.throwsAsync(async () => runParser(parser, 'foo', stringParserInputCompanion), {
+        any: true,
+        message: /Expected .* to match at least once/,
+    });
+});
+test('partial match throws error', async (t) => {
+    const parser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('element'), createExactSequenceParser(','));
+    await t.throwsAsync(async () => runParser(parser, 'elem', stringParserInputCompanion), {
+        any: true,
+        message: /Expected .* to match at least once/,
+    });
+});
+testProp('separatedNonEmptyArray with at least one element', [
+    fc.array(fc.constant('element'), { minLength: 1 }),
+], async (t, elements) => {
+    const separatedNonEmptyArrayParser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('element'), createExactSequenceParser('separator'));
+    const actual = await runParser(separatedNonEmptyArrayParser, elements.join('separator'), stringParserInputCompanion);
+    const expected = elements;
+    t.deepEqual(actual, expected);
+}, {
+    verbose: true,
+});
+test('separatedNonEmptyArray throws on empty array', async (t) => {
+    const separatedNonEmptyArrayParser = createSeparatedNonEmptyArrayParser(createExactSequenceParser('element'), createExactSequenceParser('separator'));
+    await t.throwsAsync(async () => runParser(separatedNonEmptyArrayParser, '', stringParserInputCompanion), {
+        any: true,
+        message: /Expected .* to match at least once/,
+    });
+});

package/build/sequenceBuffer.js

@@ -74,7 +74,7 @@ export class SequenceBufferImplementation {
         if (this._indexInFirstSequence === 0) {
             return {
                 consumedBufferedSequences: [],
-                unconsumedBufferedSequences: this._sequences.slice(),
+                unconsumedBufferedSequences: [...this._sequences],
             };
         }
         const firstSequence = this._sequences[0];

package/build/sequenceTerminatedSequenceParser.d.ts

@@ -1,5 +1,5 @@
-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 createSequenceTerminatedSequenceParser: <Sequence, Element = DeriveSequenceElement<Sequence>>(terminatorSequence: Sequence, { consumeTerminator, }?: {
     consumeTerminator?: boolean;
 }) => Parser<Sequence, Sequence, Element>;

package/build/sequenceTerminatedSequenceParser.js

@@ -1,5 +1,5 @@
-import { inspect } from "./inspect.js";
-import { setParserName } from "./parser.js";
+import { inspect } from './inspect.js';
+import { setParserName } from './parser.js';
 function clamp(x, min, max) {
     return Math.max(min, Math.min(x, max));
 }
@@ -17,7 +17,7 @@ export const createSequenceTerminatedSequenceParser = (terminatorSequence, { con
             nonEndOfInputWindow = Math.max(window, nonEndOfInputWindow);
             const terminatorIndex = parserContext.indexOfSubsequence(sequence, terminatorSequence);
             if (terminatorIndex === -1) {
-                window = window * 2;
+                window *= 2;
                 continue;
             }
             const sequence_ = await parserContext.readSequence(0, terminatorIndex);

package/build/sequenceTerminatedSequenceParser.test.js

@@ -15,7 +15,7 @@ testProp.serial('sequenceTerminatedSequenceParser', [
         string,
         terminator: string.slice(-terminatorLength),
     }))
-        .filter(({ string, terminator }) => string.split(terminator).length === 2)
+        .filter(({ string, terminator }) => string.split(terminator).length === 2),
 ], async (t, { string, terminator }) => {
     const sequenceTerminatedSequenceParser = createSequenceTerminatedSequenceParser(terminator);
     const createTestWrapperParser = (innerParser) => async (parserContext) => {

package/build/sequenceUnparser.d.ts

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

package/build/skipToParser.d.ts

@@ -1,2 +1,2 @@
-import { Parser } from "./parser.js";
+import { type Parser } from './parser.js';
 export declare const createSkipToParser: (offset: number) => Parser<void, Uint8Array>;

package/build/skipToParser.js

@@ -1,7 +1,7 @@
-import { setParserName } from "./parser.js";
+import { setParserName } from './parser.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 export const createSkipToParser = (offset) => {
-    const skipToParser = (parserContext) => {
+    const skipToParser = parserContext => {
         const length = offset - parserContext.position;
         parserImplementationInvariant(length >= 0, 'Skip length must be positive, got %s (position: %s)', length, parserContext.position);
         parserContext.skip(length);

package/build/sliceBoundedParser.test.js

@@ -6,13 +6,7 @@ import { createSliceBoundedParser } from './sliceBoundedParser.js';
 import { runParser, runParserWithRemainingInput } from './parser.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { createExactElementParser } from './exactElementParser.js';
-async function stringFromAsyncIterable(asyncIterable) {
-    let string = '';
-    for await (const chunk of asyncIterable) {
-        string += chunk;
-    }
-    return string;
-}
+import { stringFromAsyncIterable } from './stringFromAsyncIterable.js';
 const anythingParser = createArrayParser(createElementParser());
 test('sliceBoundedParser', async (t) => {
     const parser = createTupleParser([
@@ -36,7 +30,8 @@ test('sliceBoundedParser mustConsumeAll: true fail to cosume all', async (t) =>
         createSliceBoundedParser(createArrayParser(createExactElementParser('b')), 2),
         createElementParser(),
     ]);
-    await t.throwsAsync(() => runParser(parser, 'abcd', stringParserInputCompanion), {
+    await t.throwsAsync(async () => runParser(parser, 'abcd', stringParserInputCompanion), {
+        any: true,
         message: /child parser must consume all input in the slice/,
     });
 });
@@ -54,5 +49,5 @@ test('sliceBoundedParser mustConsumeAll: false', async (t) => {
         ],
         'c',
     ]);
-    t.deepEqual(await stringFromAsyncIterable(remainingInput), 'd');
+    t.is(await stringFromAsyncIterable(remainingInput), 'd');
 });

package/build/smali.d.ts

@@ -1 +1 @@
-export declare function smaliClass(smaliStream: AsyncIterable<string>): Promise<Buffer<ArrayBufferLike>>;
+export declare function smaliClass(smaliStream: string | AsyncIterable<string>): Promise<Uint8Array>;

package/build/smali.js

@@ -5,11 +5,15 @@ export async function smaliClass(smaliStream) {
     const inputFilePath = temporaryFile();
     const outputFilePath = temporaryFile();
     await fs.writeFile(inputFilePath, smaliStream);
-    await execa('smali', [
+    const smaliResult = await execa('smali', [
         'assemble',
-        '--output', outputFilePath,
+        '--output',
+        outputFilePath,
         inputFilePath,
     ]);
+    if (smaliResult.stderr) {
+        throw new Error(`smali error: ${smaliResult.stderr}`);
+    }
     await fs.unlink(inputFilePath);
     const dex = await fs.readFile(outputFilePath);
     await fs.unlink(outputFilePath);

package/build/smaliParser.d.ts

@@ -1,12 +1,68 @@
-import { DalvikBytecode } from "./dalvikBytecodeParser.js";
-import { DalvikExecutableClassDefinition, DalvikExecutableFieldWithAccess } from "./dalvikExecutable.js";
-import { Parser } from "./parser.js";
-export declare const smaliFieldParser: Parser<DalvikExecutableFieldWithAccess, string>;
-export declare const smaliAnnotationParser: Parser<unknown, string>;
+import { type Simplify } from 'type-fest';
+import { type DalvikBytecode, type DalvikBytecodeOperation } from './dalvikBytecodeParser.js';
+import { type DalvikExecutableClassDefinition, type DalvikExecutableField, type DalvikExecutableFieldWithAccess, type DalvikExecutableMethod, type DalvikExecutableMethodWithAccess } from './dalvikExecutable.js';
+import { type Parser } from './parser.js';
+import { type IndexIntoMethodIds } from './dalvikExecutableParser/typedNumbers.js';
+export declare const smaliCommentParser: Parser<string, string>;
+type SmaliAnnotationElementValue = {
+    kind: 'type';
+    value: string | string[];
+} | {
+    kind: 'string';
+    value: string | string[];
+} | {
+    kind: 'enum';
+    value: DalvikExecutableField | DalvikExecutableField[];
+} | {
+    kind: 'raw';
+    value: unknown;
+};
+type SmaliAnnotationElement = {
+    name: string;
+    value: SmaliAnnotationElementValue;
+};
+type SmaliAnnotation = {
+    type: string;
+    elements: SmaliAnnotationElement[];
+    visibility: 'build' | 'runtime' | 'system';
+};
+export declare const smaliAnnotationParser: Parser<SmaliAnnotation, string>;
+type SmaliField = {
+    field: DalvikExecutableFieldWithAccess;
+    annotations: SmaliAnnotation[];
+    initialValue?: number | bigint | string | boolean | null;
+};
+export declare const smaliFieldParser: Parser<SmaliField, string>;
 type SmaliRegister = {
     prefix: 'v' | 'p';
     index: number;
 };
-export declare const smaliCodeParameterParser: Parser<SmaliRegister, string>;
+type SmaliCodeParameter = {
+    register: SmaliRegister;
+    name: string | undefined;
+    annotation: SmaliAnnotation | undefined;
+};
+export declare const smaliCodeParameterParser: Parser<SmaliCodeParameter, string>;
+type SmaliCodeOperationFromDalvikBytecodeOperation<T extends DalvikBytecodeOperation> = T extends {
+    branchOffsets: number[];
+} ? Simplify<Omit<T, 'branchOffsets'> & {
+    branchOffsetIndices: number[];
+}> : T extends {
+    branchOffset: number;
+} ? Simplify<Omit<T, 'branchOffset'> & {
+    branchOffsetIndex: number;
+}> : T extends {
+    methodIndex: IndexIntoMethodIds;
+} ? Simplify<Omit<T, 'methodIndex'> & {
+    method: DalvikExecutableMethod;
+}> : T;
+type SmaliCodeOperation = SmaliCodeOperationFromDalvikBytecodeOperation<DalvikBytecodeOperation>;
+export declare const smaliCodeOperationParser: Parser<SmaliCodeOperation, string>;
+type SmaliMethod<DalvikBytecode> = {
+    dalvikExecutableMethodWithAccess: DalvikExecutableMethodWithAccess<DalvikBytecode>;
+    parameterAnnotations: SmaliCodeParameter[];
+    methodAnnotations: SmaliAnnotation[];
+};
+export declare const smaliMethodParser: Parser<SmaliMethod<DalvikBytecode>, string>;
 export declare const smaliParser: Parser<DalvikExecutableClassDefinition<DalvikBytecode>, string>;
 export {};