@futpib/parser 1.0.4 → 1.0.6

package/build/arbitraryZig.js

@@ -0,0 +1,240 @@
+import * as fc from 'fast-check';
+const zigKeywords = new Set([
+    'addrspace', 'align', 'allowzero', 'and', 'anyframe', 'anytype',
+    'asm', 'async', 'await', 'break', 'callconv', 'catch', 'comptime',
+    'const', 'continue', 'defer', 'else', 'enum', 'errdefer', 'error',
+    'export', 'extern', 'false', 'fn', 'for', 'if', 'inline',
+    'linksection', 'noalias', 'nosuspend', 'null', 'opaque', 'or',
+    'orelse', 'packed', 'pub', 'resume', 'return', 'struct',
+    'suspend', 'switch', 'test', 'threadlocal', 'true', 'try',
+    'undefined', 'union', 'unreachable', 'var', 'volatile', 'while',
+]);
+const arbitraryZigIdentifier = fc.stringMatching(/^[a-zA-Z_][a-zA-Z0-9_]*$/).filter(id => !zigKeywords.has(id));
+// Leaf expressions - safe to use as operands without precedence issues
+const arbitraryIdentifier = fc.record({
+    type: fc.constant('Identifier'),
+    name: arbitraryZigIdentifier,
+});
+const arbitraryIntegerLiteral = fc.record({
+    type: fc.constant('IntegerLiteral'),
+    value: fc.nat({ max: 999 }).map(n => String(n)),
+});
+const arbitraryStringLiteral = fc.record({
+    type: fc.constant('StringLiteral'),
+    value: fc.oneof(fc.stringMatching(/^[a-zA-Z0-9 ]*$/), fc.constantFrom('hello\nworld', 'tab\there', 'back\\slash', 'quote\ttab\nnewline')),
+});
+const arbitraryCharLiteral = fc.record({
+    type: fc.constant('CharLiteral'),
+    value: fc.stringMatching(/^[a-zA-Z0-9]$/),
+});
+const arbitraryEnumLiteral = fc.record({
+    type: fc.constant('EnumLiteral'),
+    name: arbitraryZigIdentifier,
+});
+const arbitraryBoolLiteral = fc.record({
+    type: fc.constant('BoolLiteral'),
+    value: fc.boolean(),
+});
+const arbitraryNullLiteral = fc.constant({
+    type: 'NullLiteral',
+});
+const arbitraryUndefinedLiteral = fc.constant({
+    type: 'UndefinedLiteral',
+});
+const arbitraryLeafExpression = fc.oneof({ weight: 3, arbitrary: arbitraryIdentifier }, { weight: 2, arbitrary: arbitraryIntegerLiteral }, { weight: 1, arbitrary: arbitraryStringLiteral }, { weight: 1, arbitrary: arbitraryCharLiteral }, { weight: 1, arbitrary: arbitraryEnumLiteral }, { weight: 1, arbitrary: arbitraryBoolLiteral }, { weight: 1, arbitrary: arbitraryNullLiteral }, { weight: 1, arbitrary: arbitraryUndefinedLiteral });
+// Type expressions (simple ones for use in declarations)
+const arbitrarySimpleTypeExpression = arbitraryIdentifier;
+const arbitraryOptionalType = fc.record({
+    type: fc.constant('OptionalType'),
+    child: arbitrarySimpleTypeExpression,
+});
+const arbitraryPointerType = fc.record({
+    type: fc.constant('PointerType'),
+    size: fc.oneof(fc.constant('one'), fc.constant('many'), fc.constant('slice')),
+    isConst: fc.boolean(),
+    child: arbitrarySimpleTypeExpression,
+});
+const arbitraryErrorUnionType = fc.record({
+    type: fc.constant('ErrorUnionType'),
+    error: arbitrarySimpleTypeExpression,
+    payload: arbitrarySimpleTypeExpression,
+});
+const arbitraryTypeExpression = fc.oneof({ weight: 4, arbitrary: arbitrarySimpleTypeExpression }, { weight: 1, arbitrary: arbitraryOptionalType }, { weight: 1, arbitrary: arbitraryPointerType }, { weight: 1, arbitrary: arbitraryErrorUnionType });
+// Compound expressions (use leaf operands to avoid precedence issues)
+const arbitraryBuiltinCallExpr = fc.record({
+    type: fc.constant('BuiltinCallExpr'),
+    name: arbitraryZigIdentifier,
+    args: fc.array(arbitraryLeafExpression, { maxLength: 2 }),
+});
+const arbitraryFieldAccessExpr = fc.record({
+    type: fc.constant('FieldAccessExpr'),
+    operand: arbitraryIdentifier,
+    member: arbitraryZigIdentifier,
+});
+const arbitraryCallExpr = fc.record({
+    type: fc.constant('CallExpr'),
+    callee: arbitraryIdentifier,
+    args: fc.array(arbitraryLeafExpression, { maxLength: 2 }),
+});
+const arbitraryIndexExpr = fc.record({
+    type: fc.constant('IndexExpr'),
+    operand: arbitraryIdentifier,
+    index: arbitraryLeafExpression,
+});
+const arbitraryGroupedExpr = fc.record({
+    type: fc.constant('GroupedExpr'),
+    inner: arbitraryLeafExpression,
+});
+const arbitraryErrorSetExpr = fc.record({
+    type: fc.constant('ErrorSetExpr'),
+    names: fc.array(arbitraryZigIdentifier, { minLength: 1, maxLength: 3 }),
+});
+const arbitraryStructInitExpr = fc.record({
+    type: fc.constant('StructInitExpr'),
+    fields: fc.array(fc.record({
+        type: fc.constant('StructInitField'),
+        name: arbitraryZigIdentifier,
+        value: arbitraryLeafExpression,
+    }), { maxLength: 3 }),
+});
+const arbitraryArrayInitExpr = fc.record({
+    type: fc.constant('ArrayInitExpr'),
+    elements: fc.array(arbitraryLeafExpression, { maxLength: 3 }),
+});
+const arbitraryExpression = fc.oneof({ weight: 5, arbitrary: arbitraryLeafExpression }, { weight: 1, arbitrary: arbitraryBuiltinCallExpr }, { weight: 1, arbitrary: arbitraryFieldAccessExpr }, { weight: 1, arbitrary: arbitraryCallExpr }, { weight: 1, arbitrary: arbitraryIndexExpr }, { weight: 1, arbitrary: arbitraryGroupedExpr }, { weight: 1, arbitrary: arbitraryErrorSetExpr }, { weight: 1, arbitrary: arbitraryStructInitExpr }, { weight: 1, arbitrary: arbitraryArrayInitExpr });
+// Expressions safe to use in statement positions (don't start with keywords,
+// which would cause the parser's while/for/block label detector to throw
+// a non-recoverable error from zigIdentifierParser).
+const arbitraryNonKeywordLeafExpression = fc.oneof({ weight: 3, arbitrary: arbitraryIdentifier }, { weight: 2, arbitrary: arbitraryIntegerLiteral }, { weight: 1, arbitrary: arbitraryStringLiteral }, { weight: 1, arbitrary: arbitraryCharLiteral }, { weight: 1, arbitrary: arbitraryEnumLiteral });
+const arbitraryStatementSafeExpression = fc.oneof({ weight: 5, arbitrary: arbitraryNonKeywordLeafExpression }, { weight: 1, arbitrary: arbitraryBuiltinCallExpr }, { weight: 1, arbitrary: arbitraryFieldAccessExpr }, { weight: 1, arbitrary: arbitraryCallExpr }, { weight: 1, arbitrary: arbitraryIndexExpr }, { weight: 1, arbitrary: arbitraryGroupedExpr });
+// Statements
+// Expression statements are bare expressions (no wrapper)
+const arbitraryExprStmt = arbitraryStatementSafeExpression;
+const arbitraryReturnStmt = fc.oneof(fc.constant({ type: 'ReturnStmt' }), fc.record({
+    type: fc.constant('ReturnStmt'),
+    value: arbitraryLeafExpression,
+}));
+const arbitraryBreakStmt = fc.constant({
+    type: 'BreakStmt',
+});
+const arbitraryContinueStmt = fc.constant({
+    type: 'ContinueStmt',
+});
+const arbitraryVarDeclStmt = fc.record({
+    type: fc.constant('VarDecl'),
+    isConst: fc.boolean(),
+    isPub: fc.constant(false),
+    isExtern: fc.constant(false),
+    isComptime: fc.constant(false),
+    isThreadlocal: fc.constant(false),
+    name: arbitraryZigIdentifier,
+}).chain(base => fc.oneof(
+// With type and init
+fc.record({
+    typeExpr: arbitraryTypeExpression,
+    initExpr: arbitraryLeafExpression,
+}).map(extra => ({ ...base, ...extra })), 
+// With init only
+fc.record({
+    initExpr: arbitraryLeafExpression,
+}).map(extra => ({ ...base, ...extra })), 
+// With type only (extern style)
+fc.record({
+    typeExpr: arbitraryTypeExpression,
+}).map(extra => ({ ...base, isExtern: true, ...extra }))));
+const arbitraryAssignStmt = fc.record({
+    type: fc.constant('AssignStmt'),
+    target: arbitraryIdentifier,
+    operator: fc.oneof(fc.constant('='), fc.constant('+='), fc.constant('-='), fc.constant('*=')),
+    value: arbitraryLeafExpression,
+});
+const arbitraryBlockStmt = fc.record({
+    type: fc.constant('BlockExpr'),
+    statements: fc.constant([]),
+});
+const arbitraryDeferStmt = fc.record({
+    type: fc.constant('DeferStmt'),
+    isErrdefer: fc.boolean(),
+    body: arbitraryStatementSafeExpression,
+});
+const arbitraryStatement = fc.oneof({ weight: 2, arbitrary: arbitraryExprStmt }, { weight: 2, arbitrary: arbitraryVarDeclStmt }, { weight: 2, arbitrary: arbitraryReturnStmt }, { weight: 1, arbitrary: arbitraryAssignStmt }, { weight: 1, arbitrary: arbitraryBreakStmt }, { weight: 1, arbitrary: arbitraryContinueStmt }, { weight: 1, arbitrary: arbitraryBlockStmt }, { weight: 1, arbitrary: arbitraryDeferStmt });
+// Function parameters
+const arbitraryFnParam = fc.oneof(
+// Named parameter
+fc.record({
+    type: fc.constant('FnParam'),
+    name: arbitraryZigIdentifier,
+    isComptime: fc.constant(false),
+    isNoalias: fc.constant(false),
+    typeExpr: arbitraryTypeExpression,
+}), 
+// Unnamed parameter
+fc.record({
+    type: fc.constant('FnParam'),
+    isComptime: fc.constant(false),
+    isNoalias: fc.constant(false),
+    typeExpr: arbitraryTypeExpression,
+}));
+// Block expression
+const arbitraryBlockExpr = fc.record({
+    type: fc.constant('BlockExpr'),
+    statements: fc.array(arbitraryStatement, { maxLength: 3 }),
+});
+// Top-level declarations
+const arbitraryFnDecl = fc.oneof(
+// Function with body
+fc.record({
+    type: fc.constant('FnDecl'),
+    isPub: fc.boolean(),
+    isExtern: fc.constant(false),
+    isExport: fc.constant(false),
+    isInline: fc.constant(false),
+    isComptime: fc.constant(false),
+    name: arbitraryZigIdentifier,
+    params: fc.array(arbitraryFnParam, { maxLength: 2 }),
+    returnType: arbitraryTypeExpression,
+    body: arbitraryBlockExpr,
+}), 
+// Extern function (no body)
+fc.record({
+    type: fc.constant('FnDecl'),
+    isPub: fc.boolean(),
+    isExtern: fc.constant(true),
+    isExport: fc.constant(false),
+    isInline: fc.constant(false),
+    isComptime: fc.constant(false),
+    name: arbitraryZigIdentifier,
+    params: fc.array(arbitraryFnParam, { maxLength: 2 }),
+    returnType: arbitraryTypeExpression,
+}));
+const arbitraryVarDecl = fc.record({
+    type: fc.constant('VarDecl'),
+    isConst: fc.boolean(),
+    isPub: fc.boolean(),
+    isExtern: fc.constant(false),
+    isComptime: fc.constant(false),
+    isThreadlocal: fc.constant(false),
+    name: arbitraryZigIdentifier,
+}).chain(base => fc.oneof(
+// With type and init
+fc.record({
+    typeExpr: arbitraryTypeExpression,
+    initExpr: arbitraryLeafExpression,
+}).map(extra => ({ ...base, ...extra })), 
+// With init only
+fc.record({
+    initExpr: arbitraryLeafExpression,
+}).map(extra => ({ ...base, ...extra }))));
+const arbitraryTestDecl = fc.oneof(fc.record({
+    type: fc.constant('TestDecl'),
+    name: fc.stringMatching(/^[a-zA-Z0-9 ]+$/),
+    body: arbitraryBlockExpr,
+}), fc.record({
+    type: fc.constant('TestDecl'),
+    body: arbitraryBlockExpr,
+}));
+const arbitraryContainerMember = fc.oneof({ weight: 3, arbitrary: arbitraryFnDecl }, { weight: 3, arbitrary: arbitraryVarDecl }, { weight: 1, arbitrary: arbitraryTestDecl });
+export const arbitraryZigRoot = fc.record({
+    type: fc.constant('Root'),
+    members: fc.array(arbitraryContainerMember, { minLength: 1, maxLength: 4 }),
+});

package/build/arbitraryZipStream.d.ts

@@ -2,4 +2,4 @@ import { type ZipEntry } from './zip.js';
 export declare const arbitraryZipStream: import("fast-check").Arbitrary<readonly [{
     comment: string;
     entries: ZipEntry[];
-}, ReadableStream<Uint8Array<ArrayBufferLike>>]>;
+}, import("stream/web").ReadableStream<Uint8Array<ArrayBufferLike>>]>;

package/build/arrayParser.js

@@ -1,27 +1,86 @@
+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';
 export const createArrayParser = (elementParser) => {
     const arrayParser = async (parserContext) => {
         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 elementParser(elementParserContext);
-                if (elementParserContext.position === initialPosition) {
-                    return elements;
+                const elementParserContext = __addDisposableResource(env_1, parserContext.lookahead(), false);
+                const initialPosition = elementParserContext.position;
+                try {
+                    const element = await elementParser(elementParserContext);
+                    if (elementParserContext.position === initialPosition) {
+                        return elements;
+                    }
+                    elements.push(element);
+                    elementParserContext.unlookahead();
                 }
-                elements.push(element);
-                elementParserContext.unlookahead();
-            }
-            catch (error) {
-                if (isParserParsingFailedError(error)) {
-                    return elements;
+                catch (error) {
+                    if (isParserParsingFailedError(error)) {
+                        return elements;
+                    }
+                    throw error;
                 }
-                throw error;
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
             }
             finally {
-                elementParserContext.dispose();
+                __disposeResources(env_1);
             }
         }
     };

package/build/backsmali.d.ts

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

package/build/backsmali.js

@@ -3,17 +3,18 @@ import path from 'node:path';
 import { execa } from 'execa';
 import { temporaryDirectory, temporaryFile } from 'tempy';
 import { smaliClass } from './smali.js';
-export async function baksmaliClass(dexStream, smaliFilePath) {
+export async function baksmaliClass(dexStream, smaliFilePath, dexEntry) {
     const inputFilePath = temporaryFile();
     const outputDirectoryPath = temporaryDirectory();
     await fs.writeFile(inputFilePath, dexStream);
+    const inputPath = dexEntry ? `${inputFilePath}/${dexEntry}` : inputFilePath;
     await execa('baksmali', [
         'disassemble',
         '--classes',
         'L' + smaliFilePath + ';',
         '--output',
         outputDirectoryPath,
-        inputFilePath,
+        inputPath,
     ]);
     await fs.unlink(inputFilePath);
     const smaliFilePath_ = path.join(outputDirectoryPath, smaliFilePath + '.smali');
@@ -23,17 +24,18 @@ export async function baksmaliClass(dexStream, smaliFilePath) {
     });
     return smali;
 }
-export async function backsmaliSmaliIsolateClass(dexStream, smaliFilePath) {
-    const smali = await baksmaliClass(dexStream, smaliFilePath);
+export async function backsmaliSmaliIsolateClass(dexStream, smaliFilePath, dexEntry) {
+    const smali = await baksmaliClass(dexStream, smaliFilePath, dexEntry);
     return smaliClass(smali);
 }
-export async function baksmaliListClasses(dexStream) {
+export async function baksmaliListClasses(dexStream, dexEntry) {
     const inputFilePath = temporaryFile();
     await fs.writeFile(inputFilePath, dexStream);
+    const inputPath = dexEntry ? `${inputFilePath}/${dexEntry}` : inputFilePath;
     const result = await execa('baksmali', [
         'list',
         'classes',
-        inputFilePath,
+        inputPath,
     ]);
     await fs.unlink(inputFilePath);
     if (result.stderr) {
@@ -48,3 +50,21 @@ export async function baksmaliListClasses(dexStream) {
         .replace(/;$/, '')));
     return classes;
 }
+export async function baksmaliListDexFiles(apkStream) {
+    const inputFilePath = temporaryFile();
+    await fs.writeFile(inputFilePath, apkStream);
+    const result = await execa('baksmali', [
+        'list',
+        'dex',
+        inputFilePath,
+    ]);
+    await fs.unlink(inputFilePath);
+    if (result.stderr) {
+        throw new Error(`baksmali error: ${result.stderr}`);
+    }
+    const dexFiles = result.stdout
+        .split('\n')
+        .filter(line => line.trim())
+        .map(line => line.trim());
+    return dexFiles;
+}

package/build/bash.d.ts

@@ -1,7 +1,7 @@
 export type BashWord = {
     parts: BashWordPart[];
 };
-export type BashWordPart = BashWordPartLiteral | BashWordPartSingleQuoted | BashWordPartDoubleQuoted | BashWordPartVariable | BashWordPartVariableBraced | BashWordPartCommandSubstitution | BashWordPartBacktickSubstitution | BashWordPartArithmeticExpansion;
+export type BashWordPart = BashWordPartLiteral | BashWordPartSingleQuoted | BashWordPartDoubleQuoted | BashWordPartVariable | BashWordPartVariableBraced | BashWordPartCommandSubstitution | BashWordPartBacktickSubstitution | BashWordPartArithmeticExpansion | BashWordPartProcessSubstitution;
 export type BashWordPartLiteral = {
     type: 'literal';
     value: string;
@@ -36,6 +36,11 @@ export type BashWordPartArithmeticExpansion = {
     type: 'arithmeticExpansion';
     expression: string;
 };
+export type BashWordPartProcessSubstitution = {
+    type: 'processSubstitution';
+    direction: '<' | '>';
+    command: BashCommand;
+};
 export type BashRedirect = {
     fd?: number;
     operator: '>' | '>>' | '<' | '<<' | '<<<' | '>&' | '<&' | '>|';