@futpib/parser 1.0.4 → 1.0.6

package/build/parserError.js

@@ -15,7 +15,11 @@ export function isParserParsingFailedError(value) {
         && 'depth' in value
         && typeof value.depth === 'number'
         && 'position' in value
-        && typeof value.position === 'number');
+        && typeof value.position === 'number'
+        && 'furthestReadPosition' in value
+        && typeof value.furthestReadPosition === 'number'
+        && 'furthestPeekedPosition' in value
+        && typeof value.furthestPeekedPosition === 'number');
 }
 export function isParserParsingJoinError(value) {
     return (typeof value === 'object'
@@ -40,11 +44,15 @@ function createParserErrorModule(BaseLazyMessageError) {
     class ParserParsingFailedError extends ParserError {
         depth;
         position;
+        furthestReadPosition;
+        furthestPeekedPosition;
         name = 'ParserParsingFailedError';
-        constructor(message, depth, position) {
+        constructor(message, depth, position, furthestReadPosition, furthestPeekedPosition) {
             super(message);
             this.depth = depth;
             this.position = position;
+            this.furthestReadPosition = furthestReadPosition;
+            this.furthestPeekedPosition = furthestPeekedPosition;
         }
     }
     class ParserParsingJoinError extends ParserParsingFailedError {
@@ -57,24 +65,24 @@ function createParserErrorModule(BaseLazyMessageError) {
     class ParserParsingJoinAllError extends ParserParsingJoinError {
         childErrors;
         name = 'ParserParsingJoinAllError';
-        constructor(message, depth, position, childErrors) {
-            super(message, depth, position);
+        constructor(message, depth, position, furthestReadPosition, furthestPeekedPosition, childErrors) {
+            super(message, depth, position, furthestReadPosition, furthestPeekedPosition);
             this.childErrors = childErrors;
         }
     }
     class ParserParsingJoinDeepestError extends ParserParsingJoinError {
         childErrors;
         name = 'ParserParsingJoinDeepestError';
-        constructor(message, depth, position, childErrors) {
-            super(message, depth, position);
+        constructor(message, depth, position, furthestReadPosition, furthestPeekedPosition, childErrors) {
+            super(message, depth, position, furthestReadPosition, furthestPeekedPosition);
             this.childErrors = childErrors;
         }
     }
     class ParserParsingJoinFurthestError extends ParserParsingJoinError {
         childErrors;
         name = 'ParserParsingJoinFurthestError';
-        constructor(message, depth, position, childErrors) {
-            super(message, depth, position);
+        constructor(message, depth, position, furthestReadPosition, furthestPeekedPosition, childErrors) {
+            super(message, depth, position, furthestReadPosition, furthestPeekedPosition);
             this.childErrors = childErrors;
         }
     }

package/build/regexpParser.js

@@ -5,14 +5,44 @@ export const createRegExpParser = (regexp) => {
         let window = 1;
         let lastMatch;
         let reachedEndOfInput = false;
+        let inputLength;
         while (true) {
             const sequence = await parserContext.peekSequence(start, start + window);
             if (sequence === undefined) {
-                reachedEndOfInput = true;
+                if (!reachedEndOfInput) {
+                    reachedEndOfInput = true;
+                    // Binary search to find actual input length
+                    // We know: length >= start (we've peeked successfully before)
+                    // We know: length < start + window (current peek failed)
+                    let lo = start;
+                    let hi = start + window;
+                    while (hi - lo > 1) {
+                        const mid = (lo + hi) >> 1;
+                        const probe = await parserContext.peekSequence(0, mid);
+                        if (probe !== undefined) {
+                            lo = mid;
+                        }
+                        else {
+                            hi = mid;
+                        }
+                    }
+                    inputLength = lo;
+                    // Try matching against the full input
+                    if (inputLength > 0) {
+                        const fullInput = await parserContext.peekSequence(0, inputLength);
+                        if (fullInput !== undefined) {
+                            const match = regexp.exec(fullInput);
+                            if (match !== null && match.index === 0) {
+                                parserContext.skip(match[0].length);
+                                return match;
+                            }
+                        }
+                    }
+                }
                 window = Math.floor(window / 2);
                 if (window === 0) {
                     // Get the full sequence we've accumulated to verify matches
-                    const fullSequence = await parserContext.peekSequence(0, start);
+                    const fullSequence = await parserContext.peekSequence(0, inputLength ?? start);
                     // Verify any previous match is still valid with full context
                     // For lookahead/lookbehind assertions, additional input might invalidate a match
                     if (fullSequence !== undefined) {
@@ -36,7 +66,7 @@ export const createRegExpParser = (regexp) => {
                 }
                 continue;
             }
-            const fullSequence = await parserContext.peekSequence(0, start + window);
+            const fullSequence = await parserContext.peekSequence(0, inputLength ?? start + window);
             if (fullSequence === undefined) {
                 continue;
             }

package/build/regexpParser.test.js

@@ -81,3 +81,34 @@ test('regexpParser with negative lookahead should match single char', async (t)
     t.is(position, 1); // Consumed 1 character
     t.truthy(remainingInput); // There's remaining input (the space)
 });
+test('regexpParser should match exact 6-character input', async (t) => {
+    const regexpParser = createRegExpParser(/abcdef/);
+    const result = await runParser(regexpParser, 'abcdef', stringParserInputCompanion);
+    t.is(result[0], 'abcdef');
+});
+test('regexpParser should match quoted string of length 6', async (t) => {
+    const regexpParser = createRegExpParser(/"[^"]*"/);
+    const result = await runParser(regexpParser, '"abcd"', // 6 characters total
+    stringParserInputCompanion);
+    t.is(result[0], '"abcd"');
+});
+// Property-based tests for fixed-length patterns
+testProp('regexpParser should match exact n-character input for any length', [fc.integer({ min: 1, max: 20 })], async (t, length) => {
+    const input = 'a'.repeat(length);
+    const regex = new RegExp(`a{${length}}`);
+    const regexpParser = createRegExpParser(regex);
+    const result = await runParser(regexpParser, input, stringParserInputCompanion);
+    t.is(result[0], input);
+});
+testProp('regexpParser should match quoted strings of any length', [fc.integer({ min: 0, max: 20 })], async (t, contentLength) => {
+    const content = 'x'.repeat(contentLength);
+    const input = `"${content}"`;
+    const regexpParser = createRegExpParser(/"[^"]*"/);
+    const result = await runParser(regexpParser, input, stringParserInputCompanion);
+    t.is(result[0], input);
+});
+testProp('regexpParser greedy patterns should match any length input', [fc.stringMatching(/^[a-z]+$/).filter(s => s.length > 0 && s.length <= 20)], async (t, input) => {
+    const regexpParser = createRegExpParser(/[a-z]+/);
+    const result = await runParser(regexpParser, input, stringParserInputCompanion);
+    t.is(result[0], input);
+});

package/build/regularExpressionParser.js

@@ -11,6 +11,7 @@ import { createFixedLengthSequenceParser } from './fixedLengthSequenceParser.js'
 import { createTerminatedArrayParser } from './terminatedArrayParser.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
 import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { createObjectParser } from './objectParser.js';
 // CharacterSet helpers
 const emptyCharacterSet = { type: 'empty' };
 function codePointRangeIsEmpty(range) {
@@ -401,9 +402,18 @@ const characterClassParser = promiseCompose(createTupleParser([
     }
     return literal(charset);
 });
-const starQuantifierParser = promiseCompose(createExactSequenceParser('*'), () => ({ type: 'star' }));
-const plusQuantifierParser = promiseCompose(createExactSequenceParser('+'), () => ({ type: 'plus' }));
-const optionalQuantifierParser = promiseCompose(createExactSequenceParser('?'), () => ({ type: 'optional' }));
+const starQuantifierParser = createObjectParser({
+    type: 'star',
+    _marker: createExactSequenceParser('*'),
+});
+const plusQuantifierParser = createObjectParser({
+    type: 'plus',
+    _marker: createExactSequenceParser('+'),
+});
+const optionalQuantifierParser = createObjectParser({
+    type: 'optional',
+    _marker: createExactSequenceParser('?'),
+});
 // Parse a number for quantifiers
 const numberParser = parserCreatorCompose(() => createArrayParser(parserCreatorCompose(() => elementParser, char => async (parserContext) => {
     parserContext.invariant(char >= '0' && char <= '9', 'Expected digit, got "%s"', char);
@@ -465,24 +475,34 @@ const nonCaptureGroupParser = promiseCompose(createTupleParser([
     createExactSequenceParser(')'),
 ]), ([, inner]) => inner);
 // Positive lookahead (?=...)
-const positiveLookaheadMarkerParser = promiseCompose(createTupleParser([
-    createExactSequenceParser('(?='),
-    createParserAccessorParser(() => alternationParser),
-    createExactSequenceParser(')'),
-]), ([, inner]) => ({ type: 'lookahead-marker', isPositive: true, inner }));
+const positiveLookaheadMarkerParser = createObjectParser({
+    type: 'lookahead-marker',
+    isPositive: true,
+    _open: createExactSequenceParser('(?='),
+    inner: createParserAccessorParser(() => alternationParser),
+    _close: createExactSequenceParser(')'),
+});
 // Negative lookahead (?!...)
-const negativeLookaheadMarkerParser = promiseCompose(createTupleParser([
-    createExactSequenceParser('(?!'),
-    createParserAccessorParser(() => alternationParser),
-    createExactSequenceParser(')'),
-]), ([, inner]) => ({ type: 'lookahead-marker', isPositive: false, inner }));
+const negativeLookaheadMarkerParser = createObjectParser({
+    type: 'lookahead-marker',
+    isPositive: false,
+    _open: createExactSequenceParser('(?!'),
+    inner: createParserAccessorParser(() => alternationParser),
+    _close: createExactSequenceParser(')'),
+});
 const groupParser = createUnionParser([
     namedCaptureGroupParser,
     nonCaptureGroupParser,
     captureGroupParser,
 ]);
-const startAnchorMarkerParser = promiseCompose(createExactSequenceParser('^'), () => ({ type: 'start-anchor-marker' }));
-const endAnchorMarkerParser = promiseCompose(createExactSequenceParser('$'), () => ({ type: 'end-anchor-marker' }));
+const startAnchorMarkerParser = createObjectParser({
+    type: 'start-anchor-marker',
+    _marker: createExactSequenceParser('^'),
+});
+const endAnchorMarkerParser = createObjectParser({
+    type: 'end-anchor-marker',
+    _marker: createExactSequenceParser('$'),
+});
 // Atom: the basic unit that can be quantified (excluding anchors)
 const atomParser = createUnionParser([
     groupParser,

package/build/separatedArrayParser.js

@@ -1,3 +1,55 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { getParserName, setParserName } from './parser.js';
 import { isParserParsingFailedError } from './parserError.js';
 import { promiseCompose } from './promiseCompose.js';
@@ -11,26 +63,33 @@ export const createSeparatedArrayParser = (elementParser, separatorParser) => {
         let parser = elementParser;
         const elements = [];
         while (true) {
-            const elementParserContext = parserContext.lookahead();
-            const initialPosition = elementParserContext.position;
+            const env_1 = { stack: [], error: void 0, hasError: false };
             try {
-                const element = await parser(elementParserContext);
-                if (elementParserContext.position === initialPosition) {
-                    break;
+                const elementParserContext = __addDisposableResource(env_1, parserContext.lookahead(), false);
+                const initialPosition = elementParserContext.position;
+                try {
+                    const element = await parser(elementParserContext);
+                    if (elementParserContext.position === initialPosition) {
+                        break;
+                    }
+                    elements.push(element);
+                    elementParserContext.unlookahead();
                 }
-                elements.push(element);
-                elementParserContext.unlookahead();
-            }
-            catch (error) {
-                if (isParserParsingFailedError(error)) {
-                    break;
+                catch (error) {
+                    if (isParserParsingFailedError(error)) {
+                        break;
+                    }
+                    throw error;
                 }
-                throw error;
+                parser = separatorThenElementParser;
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
             }
             finally {
-                elementParserContext.dispose();
+                __disposeResources(env_1);
             }
-            parser = separatorThenElementParser;
         }
         return elements;
     };

package/build/separatedNonEmptyArrayParser.js

@@ -1,3 +1,55 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { getParserName, setParserName } from './parser.js';
 import { isParserParsingFailedError } from './parserError.js';
 import { promiseCompose } from './promiseCompose.js';
@@ -11,26 +63,33 @@ export const createSeparatedNonEmptyArrayParser = (elementParser, separatorParse
         let parser = elementParser;
         const elements = [];
         while (true) {
-            const elementParserContext = parserContext.lookahead();
-            const initialPosition = elementParserContext.position;
+            const env_1 = { stack: [], error: void 0, hasError: false };
             try {
-                const element = await parser(elementParserContext);
-                if (elementParserContext.position === initialPosition) {
-                    break;
+                const elementParserContext = __addDisposableResource(env_1, parserContext.lookahead(), false);
+                const initialPosition = elementParserContext.position;
+                try {
+                    const element = await parser(elementParserContext);
+                    if (elementParserContext.position === initialPosition) {
+                        break;
+                    }
+                    elements.push(element);
+                    elementParserContext.unlookahead();
                 }
-                elements.push(element);
-                elementParserContext.unlookahead();
-            }
-            catch (error) {
-                if (isParserParsingFailedError(error)) {
-                    break;
+                catch (error) {
+                    if (isParserParsingFailedError(error)) {
+                        break;
+                    }
+                    throw error;
                 }
-                throw error;
+                parser = separatorThenElementParser;
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
             }
             finally {
-                elementParserContext.dispose();
+                __disposeResources(env_1);
             }
-            parser = separatorThenElementParser;
         }
         parserContext.invariant(elements.length > 0, 'Expected elementParser (%s) to match at least once', getParserName(elementParser, 'anonymousSeparatedNonEmptyArrayChild'));
         return elements;

package/build/sliceBoundedParser.js

@@ -1,19 +1,76 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { getParserName, setParserName } from './parser.js';
 export const createSliceBoundedParser = (childParser, sliceEnd, mustConsumeAll = true) => {
     const sliceBoundedParser = async (parserContext) => {
-        const absoluteSliceEnd = parserContext.position + sliceEnd;
-        const childParserContext = parserContext.lookahead({
-            sliceEnd: absoluteSliceEnd,
-        });
+        const env_1 = { stack: [], error: void 0, hasError: false };
         try {
+            const absoluteSliceEnd = parserContext.position + sliceEnd;
+            const childParserContext = __addDisposableResource(env_1, parserContext.lookahead({
+                sliceEnd: absoluteSliceEnd,
+            }), false);
             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;
         }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
         finally {
-            childParserContext.dispose();
+            __disposeResources(env_1);
         }
     };
     setParserName(sliceBoundedParser, [

package/build/smaliParser.d.ts

@@ -1,5 +1,5 @@
 import { type Simplify } from 'type-fest';
-import { type DalvikBytecode, type DalvikBytecodeOperation } from './dalvikBytecodeParser.js';
+import { type DalvikBytecodeOperation, type DalvikBytecode } from './dalvikBytecodeParser/addressConversion.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';
@@ -43,20 +43,20 @@ type SmaliCodeParameter = {
     annotation: SmaliAnnotation | undefined;
 };
 export declare const smaliCodeParameterParser: Parser<SmaliCodeParameter, string>;
-type SmaliCodeOperationFromDalvikBytecodeOperation<T extends DalvikBytecodeOperation> = T extends {
-    branchOffsets: number[];
-} ? Simplify<Omit<T, 'branchOffsets'> & {
+type SmaliCodeOperationFromDalvikOperation<T extends DalvikBytecodeOperation> = T extends {
+    targetInstructionIndices: number[];
+} ? Simplify<Omit<T, 'targetInstructionIndices'> & {
     branchOffsetIndices: number[];
 }> : T extends {
-    branchOffset: number;
-} ? Simplify<Omit<T, 'branchOffset'> & {
+    targetInstructionIndex: number;
+} ? Simplify<Omit<T, 'targetInstructionIndex'> & {
     branchOffsetIndex: number;
 }> : T extends {
     methodIndex: IndexIntoMethodIds;
 } ? Simplify<Omit<T, 'methodIndex'> & {
     method: DalvikExecutableMethod;
 }> : T;
-type SmaliCodeOperation = SmaliCodeOperationFromDalvikBytecodeOperation<DalvikBytecodeOperation>;
+type SmaliCodeOperation = SmaliCodeOperationFromDalvikOperation<DalvikBytecodeOperation>;
 export declare const smaliCodeOperationParser: Parser<SmaliCodeOperation, string>;
 type SmaliMethod<DalvikBytecode> = {
     dalvikExecutableMethodWithAccess: DalvikExecutableMethodWithAccess<DalvikBytecode>;