@futpib/parser 1.0.1 → 1.0.2

package/build/separatedArrayParser.js

@@ -0,0 +1,39 @@
+import { getParserName, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+export const createSeparatedArrayParser = (elementParser, separatorParser) => {
+    const separatorThenElementParser = promiseCompose(createTupleParser([
+        separatorParser,
+        elementParser,
+    ]), ([, element]) => element);
+    const separatedArrayParser = 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 (error instanceof ParserParsingFailedError) {
+                    break;
+                }
+                throw error;
+            }
+            finally {
+                elementParserContext.dispose();
+            }
+            parser = separatorThenElementParser;
+        }
+        return elements;
+    };
+    setParserName(separatedArrayParser, getParserName(elementParser, 'anonymousSeparatedArrayChild') + '*');
+    return separatedArrayParser;
+};

package/build/separatedArrayParser.test.d.ts

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

package/build/separatedArrayParser.test.js

@@ -0,0 +1,21 @@
+import test from 'ava';
+import { testProp, fc } from '@fast-check/ava';
+import { createSeparatedArrayParser } from './separatedArrayParser.js';
+import { runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+test('does not loop forever with a child parser that does not consume anything', async (t) => {
+    const parser = createSeparatedArrayParser(async () => undefined, () => undefined);
+    const { output } = await runParserWithRemainingInput(parser, 'foo', stringParserInputCompanion);
+    t.deepEqual(output, []);
+});
+testProp('separatedArray', [
+    fc.array(fc.constant('element')),
+], async (t, elements) => {
+    const separatedArrayParser = createSeparatedArrayParser(createExactSequenceParser('element'), createExactSequenceParser('separator'));
+    const actual = await runParser(separatedArrayParser, elements.join('separator'), stringParserInputCompanion);
+    const expected = elements;
+    t.deepEqual(actual, expected);
+}, {
+    verbose: true,
+});

package/build/sequenceBuffer.d.ts

@@ -1,15 +1,25 @@
 import { type ParserInputCompanion } from './parserInputCompanion.js';
+export type SequenceBufferState<Sequence> = {
+    consumedBufferedSequences: Sequence[];
+    unconsumedBufferedSequences: Sequence[];
+};
 export type SequenceBuffer<Sequence, Element> = {
     push(sequence: Sequence): void;
     peek(offset: number): Element | undefined;
+    peekSequence(start: number, end: number): Sequence | undefined;
     skip(offset: number): void;
+    toSequenceBufferState(): SequenceBufferState<Sequence>;
 };
 export declare class SequenceBufferImplementation<Sequence, Element> implements SequenceBuffer<Sequence, Element> {
     private readonly _parserInputCompanion;
     private readonly _sequences;
     private _indexInFirstSequence;
     constructor(_parserInputCompanion: ParserInputCompanion<Sequence, Element>);
+    get length(): number;
+    private _shift;
     push(sequence: Sequence): void;
     peek(offset: number): Element | undefined;
+    peekSequence(start: number, end: number): Sequence | undefined;
     skip(offset: number): void;
+    toSequenceBufferState(): SequenceBufferState<Sequence>;
 }

package/build/sequenceBuffer.js

@@ -6,8 +6,10 @@ export class SequenceBufferImplementation {
     constructor(_parserInputCompanion) {
         this._parserInputCompanion = _parserInputCompanion;
     }
-    push(sequence) {
-        this._sequences.push(sequence);
+    get length() {
+        return this._sequences.reduce((sequenceLength, sequence) => sequenceLength + this._parserInputCompanion.length(sequence), 0 - this._indexInFirstSequence);
+    }
+    _shift() {
         while (this._sequences.length > 0) {
             const firstSequence = this._sequences[0];
             const firstSequenceLength = this._parserInputCompanion.length(firstSequence);
@@ -22,6 +24,10 @@ export class SequenceBufferImplementation {
             this._indexInFirstSequence -= firstSequenceLength;
         }
     }
+    push(sequence) {
+        this._sequences.push(sequence);
+        this._shift();
+    }
     peek(offset) {
         invariant(offset >= 0, 'Offset must be non-negative.');
         let index = this._indexInFirstSequence + offset;
@@ -34,7 +40,53 @@ export class SequenceBufferImplementation {
         }
         return undefined;
     }
+    peekSequence(start, end) {
+        invariant(start >= 0, 'Start must be non-negative.');
+        invariant(end >= start, 'End must be greater than or equal to start.');
+        let startIndex = this._indexInFirstSequence + start;
+        let endIndex = this._indexInFirstSequence + end;
+        const sequences = [];
+        for (const sequence of this._sequences) {
+            const sequenceLength = this._parserInputCompanion.length(sequence);
+            if (startIndex < sequenceLength) {
+                const subsequence = this._parserInputCompanion.subsequence(sequence, Math.max(0, startIndex), Math.min(sequenceLength, endIndex));
+                sequences.push(subsequence);
+            }
+            startIndex -= sequenceLength;
+            endIndex -= sequenceLength;
+            if (endIndex <= 0) {
+                break;
+            }
+        }
+        return endIndex > 0 ? undefined : this._parserInputCompanion.concat(sequences);
+    }
     skip(offset) {
         this._indexInFirstSequence += offset;
+        this._shift();
+    }
+    toSequenceBufferState() {
+        if (this._sequences.length === 0) {
+            return {
+                consumedBufferedSequences: [],
+                unconsumedBufferedSequences: [],
+            };
+        }
+        if (this._indexInFirstSequence === 0) {
+            return {
+                consumedBufferedSequences: [],
+                unconsumedBufferedSequences: this._sequences.slice(),
+            };
+        }
+        const firstSequence = this._sequences[0];
+        const firstSequenceLength = this._parserInputCompanion.length(firstSequence);
+        const consumedFirstSequence = this._parserInputCompanion.subsequence(firstSequence, 0, this._indexInFirstSequence);
+        const unconsumedFirstSequence = this._parserInputCompanion.subsequence(firstSequence, this._indexInFirstSequence, firstSequenceLength);
+        const unconsumedFirstSequenceLength = this._parserInputCompanion.length(unconsumedFirstSequence);
+        return {
+            consumedBufferedSequences: [consumedFirstSequence],
+            unconsumedBufferedSequences: (unconsumedFirstSequenceLength === 0
+                ? this._sequences.slice(1)
+                : [unconsumedFirstSequence, ...this._sequences.slice(1)]),
+        };
     }
 }

package/build/sequenceBuffer.test.js

@@ -3,32 +3,89 @@ import { SequenceBufferImplementation } from './sequenceBuffer.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 test('sequenceBuffer', t => {
     const sequenceBuffer = new SequenceBufferImplementation(stringParserInputCompanion);
+    t.is(sequenceBuffer.length, 0);
     t.is(sequenceBuffer.peek(0), undefined);
+    t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+        consumedBufferedSequences: [],
+        unconsumedBufferedSequences: [],
+    });
     sequenceBuffer.push('');
+    t.is(sequenceBuffer.length, 0);
     t.is(sequenceBuffer.peek(0), undefined);
+    t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+        consumedBufferedSequences: [],
+        unconsumedBufferedSequences: [],
+    });
     sequenceBuffer.push('abc');
+    t.is(sequenceBuffer.length, 3);
     t.is(sequenceBuffer.peek(0), 'a');
     t.is(sequenceBuffer.peek(1), 'b');
     t.is(sequenceBuffer.peek(2), 'c');
     t.is(sequenceBuffer.peek(3), undefined);
+    t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+        consumedBufferedSequences: [],
+        unconsumedBufferedSequences: ['abc'],
+    });
     sequenceBuffer.push('def');
+    t.is(sequenceBuffer.length, 6);
     t.is(sequenceBuffer.peek(0), 'a');
     t.is(sequenceBuffer.peek(3), 'd');
     t.is(sequenceBuffer.peek(6), undefined);
+    t.is(sequenceBuffer.peekSequence(1, 4), 'abcdef'.slice(1, 4), 'bcd');
+    t.is(sequenceBuffer.peekSequence(1, 5), 'abcdef'.slice(1, 5), 'bcde');
+    t.is(sequenceBuffer.peekSequence(1, 6), 'abcdef'.slice(1, 6), 'bcdef');
+    t.is(sequenceBuffer.peekSequence(1, 7), undefined, 'bcdef?');
+    t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+        consumedBufferedSequences: [],
+        unconsumedBufferedSequences: ['abc', 'def'],
+    });
     sequenceBuffer.push('');
+    t.is(sequenceBuffer.length, 6);
     t.is(sequenceBuffer.peek(0), 'a');
     t.is(sequenceBuffer.peek(3), 'd');
     t.is(sequenceBuffer.peek(6), undefined);
+    t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+        consumedBufferedSequences: [],
+        unconsumedBufferedSequences: ['abc', 'def', ''],
+    });
     sequenceBuffer.skip(1);
+    t.is(sequenceBuffer.length, 5);
     t.is(sequenceBuffer.peek(0), 'b');
     t.is(sequenceBuffer.peek(3), 'e');
     t.is(sequenceBuffer.peek(5), undefined);
+    t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+        consumedBufferedSequences: ['a'],
+        unconsumedBufferedSequences: ['bc', 'def', ''],
+    });
     sequenceBuffer.skip(3);
+    t.is(sequenceBuffer.length, 2);
     t.is(sequenceBuffer.peek(0), 'e');
     t.is(sequenceBuffer.peek(2), undefined);
+    t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+        consumedBufferedSequences: ['d'],
+        unconsumedBufferedSequences: ['ef', ''],
+    });
     sequenceBuffer.push('gh');
+    t.is(sequenceBuffer.length, 4);
     t.is(sequenceBuffer.peek(0), 'e');
     t.is(sequenceBuffer.peek(2), 'g');
     t.is(sequenceBuffer.peek(3), 'h');
     t.is(sequenceBuffer.peek(4), undefined);
+    t.is(sequenceBuffer.peekSequence(1, 3), 'efgh'.slice(1, 3), 'fg');
+    t.is(sequenceBuffer.peekSequence(1, 4), 'efgh'.slice(1, 4), 'fgh');
+    t.is(sequenceBuffer.peekSequence(1, 5), undefined, 'fgh?');
+    t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+        consumedBufferedSequences: ['d'],
+        unconsumedBufferedSequences: ['ef', '', 'gh'],
+    });
+});
+test('skip more then first sequence length', t => {
+    const sequenceBuffer = new SequenceBufferImplementation(stringParserInputCompanion);
+    sequenceBuffer.push('a');
+    sequenceBuffer.push('b');
+    sequenceBuffer.skip(2);
+    t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
+        consumedBufferedSequences: [],
+        unconsumedBufferedSequences: [],
+    });
 });

package/build/sequenceTerminatedSequenceParser.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from "./parser.js";
+import { 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

@@ -0,0 +1,32 @@
+import { inspect } from "./inspect.js";
+import { setParserName } from "./parser.js";
+function clamp(x, min, max) {
+    return Math.max(min, Math.min(x, max));
+}
+export const createSequenceTerminatedSequenceParser = (terminatorSequence, { consumeTerminator = true, } = {}) => {
+    const elementTerminatedSequenceParser = async (parserContext) => {
+        let window = 1;
+        let nonEndOfInputWindow = 0;
+        while (true) {
+            const sequence = await parserContext.peekSequence(0, window);
+            if (sequence === undefined) {
+                window = clamp(Math.floor(window * 0.75), nonEndOfInputWindow + 1, window - 1);
+                parserContext.invariant(window !== nonEndOfInputWindow, 'Unexpected end of input without terminated sequence');
+                continue;
+            }
+            nonEndOfInputWindow = Math.max(window, nonEndOfInputWindow);
+            const terminatorIndex = parserContext.indexOfSubsequence(sequence, terminatorSequence);
+            if (terminatorIndex === -1) {
+                window = window * 2;
+                continue;
+            }
+            const sequence_ = await parserContext.readSequence(0, terminatorIndex);
+            if (consumeTerminator) {
+                parserContext.skip(parserContext.length(terminatorSequence));
+            }
+            return sequence_;
+        }
+    };
+    setParserName(elementTerminatedSequenceParser, `.*?${inspect(terminatorSequence)}`);
+    return elementTerminatedSequenceParser;
+};

package/build/sequenceTerminatedSequenceParser.test.d.ts

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

package/build/sequenceTerminatedSequenceParser.test.js

@@ -0,0 +1,37 @@
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createSequenceTerminatedSequenceParser } from './sequenceTerminatedSequenceParser.js';
+testProp.serial('sequenceTerminatedSequenceParser', [
+    fc.tuple(fc
+        .string({
+        minLength: 1,
+    }), fc
+        .integer({
+        min: 1,
+    }))
+        .map(([string, terminatorLength]) => ({
+        string,
+        terminator: string.slice(-terminatorLength),
+    }))
+        .filter(({ string, terminator }) => string.split(terminator).length === 2)
+], async (t, { string, terminator }) => {
+    const sequenceTerminatedSequenceParser = createSequenceTerminatedSequenceParser(terminator);
+    const createTestWrapperParser = (innerParser) => async (parserContext) => {
+        const string = await innerParser(parserContext);
+        return {
+            string,
+            nextPeek: await parserContext.peek(0),
+            position: parserContext.position,
+        };
+    };
+    const actual = await runParser(createTestWrapperParser(sequenceTerminatedSequenceParser), string, stringParserInputCompanion);
+    t.deepEqual(actual, {
+        string: string.split(terminator)[0],
+        nextPeek: undefined,
+        position: string.length,
+    });
+}, {
+    verbose: true,
+});

package/build/skipParser.d.ts

@@ -1,2 +1,2 @@
 import { type Parser } from './parser.js';
-export declare const createSkipParser: <Sequence>(length: number) => Parser<undefined, Sequence, unknown>;
+export declare const createSkipParser: <Sequence>(length: number) => Parser<void, Sequence, unknown>;

package/build/skipParser.js

@@ -1,8 +1,10 @@
+import { setParserName } from './parser.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 export const createSkipParser = (length) => {
     parserImplementationInvariant(length > 0, 'Length must be positive.');
-    return async (parserContext) => {
+    const skipParser = parserContext => {
         parserContext.skip(length);
-        return undefined;
     };
+    setParserName(skipParser, `createSkipParser(${length})`);
+    return skipParser;
 };

package/build/skipToParser.d.ts

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

package/build/skipToParser.js

@@ -0,0 +1,11 @@
+import { setParserName } from "./parser.js";
+import { parserImplementationInvariant } from './parserImplementationInvariant.js';
+export const createSkipToParser = (offset) => {
+    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);
+    };
+    setParserName(skipToParser, `createSkipToParser(${offset})`);
+    return skipToParser;
+};

package/build/sliceBoundedParser.d.ts

@@ -1,2 +1,2 @@
 import { type Parser } from './parser.js';
-export declare const createSliceBoundedParser: <Output, Sequence>(childParser: Parser<Output, Sequence>, sliceEnd: number) => Parser<Output, Sequence>;
+export declare const createSliceBoundedParser: <Output, Sequence>(childParser: Parser<Output, Sequence>, sliceEnd: number, mustConsumeAll?: boolean) => Parser<Output, Sequence>;

package/build/sliceBoundedParser.js

@@ -1,11 +1,14 @@
 import { getParserName, setParserName } from './parser.js';
-export const createSliceBoundedParser = (childParser, sliceEnd) => {
+export const createSliceBoundedParser = (childParser, sliceEnd, mustConsumeAll = true) => {
     const sliceBoundedParser = async (parserContext) => {
+        const absoluteSliceEnd = parserContext.position + sliceEnd;
         const childParserContext = parserContext.lookahead({
-            sliceEnd: parserContext.position + sliceEnd,
+            sliceEnd: absoluteSliceEnd,
         });
         try {
             const value = await childParser(childParserContext);
+            childParserContext.invariant((!mustConsumeAll
+                || childParserContext.position === absoluteSliceEnd), 'child parser must consume all input in the slice (%s in total, up to position %s), instead consumed %s up to position %s', sliceEnd, absoluteSliceEnd, childParserContext.position - parserContext.position, childParserContext.position);
             childParserContext.unlookahead();
             return value;
         }
@@ -18,6 +21,8 @@ export const createSliceBoundedParser = (childParser, sliceEnd) => {
         getParserName(childParser, 'anonymousSliceBoundedChild'),
         ',',
         sliceEnd,
+        ',',
+        mustConsumeAll,
         ')',
     ].join(''));
     return sliceBoundedParser;

package/build/sliceBoundedParser.test.js

@@ -3,8 +3,16 @@ import { createArrayParser } from './arrayParser.js';
 import { createElementParser } from './elementParser.js';
 import { createTupleParser } from './tupleParser.js';
 import { createSliceBoundedParser } from './sliceBoundedParser.js';
-import { runParser } from './parser.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;
+}
 const anythingParser = createArrayParser(createElementParser());
 test('sliceBoundedParser', async (t) => {
     const parser = createTupleParser([
@@ -22,3 +30,29 @@ test('sliceBoundedParser', async (t) => {
         'a',
     ]);
 });
+test('sliceBoundedParser mustConsumeAll: true fail to cosume all', async (t) => {
+    const parser = createTupleParser([
+        createElementParser(),
+        createSliceBoundedParser(createArrayParser(createExactElementParser('b')), 2),
+        createElementParser(),
+    ]);
+    await t.throwsAsync(() => runParser(parser, 'abcd', stringParserInputCompanion), {
+        message: /child parser must consume all input in the slice/,
+    });
+});
+test('sliceBoundedParser mustConsumeAll: false', async (t) => {
+    const parser = createTupleParser([
+        createElementParser(),
+        createSliceBoundedParser(createArrayParser(createExactElementParser('b')), 2, false),
+        createElementParser(),
+    ]);
+    const { output, remainingInput } = await runParserWithRemainingInput(parser, 'abcd', stringParserInputCompanion);
+    t.deepEqual(output, [
+        'a',
+        [
+            'b',
+        ],
+        'c',
+    ]);
+    t.deepEqual(await stringFromAsyncIterable(remainingInput), 'd');
+});

package/build/smali.d.ts

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

package/build/smali.js

@@ -0,0 +1,17 @@
+import fs from 'node:fs/promises';
+import { execa } from 'execa';
+import { temporaryFile } from 'tempy';
+export async function smaliClass(smaliStream) {
+    const inputFilePath = temporaryFile();
+    const outputFilePath = temporaryFile();
+    await fs.writeFile(inputFilePath, smaliStream);
+    await execa('smali', [
+        'assemble',
+        '--output', outputFilePath,
+        inputFilePath,
+    ]);
+    await fs.unlink(inputFilePath);
+    const dex = await fs.readFile(outputFilePath);
+    await fs.unlink(outputFilePath);
+    return dex;
+}

package/build/smaliParser.d.ts

@@ -0,0 +1,12 @@
+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>;
+type SmaliRegister = {
+    prefix: 'v' | 'p';
+    index: number;
+};
+export declare const smaliCodeParameterParser: Parser<SmaliRegister, string>;
+export declare const smaliParser: Parser<DalvikExecutableClassDefinition<DalvikBytecode>, string>;
+export {};