@futpib/parser 1.0.3 → 1.0.6

package/build/regularExpressionParser.test.js

@@ -0,0 +1,89 @@
+import { testProp, fc } from '@fast-check/ava';
+import { regularExpressionParser } from './regularExpressionParser.js';
+const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+// Import directly from file path to bypass package exports
+// eslint-disable-next-line import/no-unresolved
+import { parseRegExpString } from '../node_modules/@gruhn/regex-utils/dist/regex-parser.js';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { arbitrarilySlicedAsyncIterator } from './arbitrarilySlicedAsyncInterator.js';
+// Normalize AST for comparison - removes hashes from CharSets and normalizes structure
+function normalizeCharacterSet(charset) {
+    if (charset.type === 'empty') {
+        return { type: 'empty' };
+    }
+    return {
+        type: 'node',
+        range: { start: charset.range.start, end: charset.range.end },
+        left: normalizeCharacterSet(charset.left),
+        right: normalizeCharacterSet(charset.right),
+    };
+}
+function normalizeRegularExpression(ast) {
+    switch (ast.type) {
+        case 'epsilon':
+            return { type: 'epsilon' };
+        case 'literal':
+            return { type: 'literal', charset: normalizeCharacterSet(ast.charset) };
+        case 'concat':
+            return { type: 'concat', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+        case 'union':
+            return { type: 'union', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+        case 'star':
+            return { type: 'star', inner: normalizeRegularExpression(ast.inner) };
+        case 'plus':
+            return { type: 'plus', inner: normalizeRegularExpression(ast.inner) };
+        case 'optional':
+            return { type: 'optional', inner: normalizeRegularExpression(ast.inner) };
+        case 'repeat':
+            return { type: 'repeat', inner: normalizeRegularExpression(ast.inner), bounds: ast.bounds };
+        case 'capture-group':
+            if (ast.name !== undefined) {
+                return { type: 'capture-group', inner: normalizeRegularExpression(ast.inner), name: ast.name };
+            }
+            return { type: 'capture-group', inner: normalizeRegularExpression(ast.inner) };
+        case 'lookahead':
+            return { type: 'lookahead', isPositive: ast.isPositive, inner: normalizeRegularExpression(ast.inner), right: normalizeRegularExpression(ast.right) };
+        case 'start-anchor':
+            return { type: 'start-anchor', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+        case 'end-anchor':
+            return { type: 'end-anchor', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+    }
+}
+// Generate regex patterns that are likely to be supported
+const supportedRegexArbitrary = fc.stringMatching(/^([a-zA-Z0-9]|\\[dDwWsS.]|\[(\^)?([a-zA-Z0-9](-[a-zA-Z0-9])?|\\[dDwWsS])*\]|\.|\((\?[:=!])?[a-zA-Z0-9]*\)|[*+?]|\{[0-9]+(,[0-9]*)?\}|\||\^|\$)*$/).filter(s => {
+    // Filter out patterns that JavaScript doesn't support
+    try {
+        new RegExp(s);
+    }
+    catch {
+        return false;
+    }
+    // Filter out patterns that @gruhn/regex-utils doesn't support
+    try {
+        parseRegExpString(s);
+    }
+    catch {
+        return false;
+    }
+    // Filter out quantified lookaheads - @gruhn/regex-utils has a bug where it treats
+    // quantifiers after lookaheads as literals instead of quantifiers.
+    // See: https://github.com/gruhn/regex-utils/issues/13
+    // JavaScript allows (?=a){2} but @gruhn/regex-utils parses {2} as literal text.
+    if (/\(\?[=!][^)]*\)[*+?]|\(\?[=!][^)]*\)\{[0-9]/.test(s)) {
+        return false;
+    }
+    return true;
+});
+testProp('regularExpressionParser matches @gruhn/regex-utils', [
+    arbitrarilySlicedAsyncIterator(supportedRegexArbitrary),
+], async (t, [regexStr, regexStringChunkIterator]) => {
+    const expected = normalizeRegularExpression(parseRegExpString(regexStr));
+    const actual = normalizeRegularExpression(await runParser(regularExpressionParser, regexStringChunkIterator, stringParserInputCompanion, {
+        errorJoinMode: 'none',
+    }));
+    t.deepEqual(actual, expected);
+}, {
+    verbose: true,
+    seed,
+});

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>;