@futpib/parser 1.0.1 → 1.0.3

package/build/dalvikExecutable.d.ts

@@ -0,0 +1,215 @@
+export type DalvikExecutableAccessFlags = {
+    public: boolean;
+    private: boolean;
+    protected: boolean;
+    static: boolean;
+    final: boolean;
+    synchronized: boolean;
+    volatile: boolean;
+    bridge: boolean;
+    transient: boolean;
+    varargs: boolean;
+    native: boolean;
+    interface: boolean;
+    abstract: boolean;
+    strict: boolean;
+    synthetic: boolean;
+    annotation: boolean;
+    enum: boolean;
+    constructor: boolean;
+    declaredSynchronized: boolean;
+};
+export declare function dalvikExecutableAccessFlagsDefault(): DalvikExecutableAccessFlags;
+export type DalvikExecutableEncodedValue = {
+    type: 'byte';
+    value: number;
+} | {
+    type: 'short';
+    value: number;
+} | {
+    type: 'char';
+    value: number;
+} | {
+    type: 'int';
+    value: number;
+} | {
+    type: 'long';
+    value: bigint;
+} | {
+    type: 'float';
+    value: number;
+} | {
+    type: 'double';
+    value: number;
+} | {
+    type: 'methodType';
+    value: DalvikExecutablePrototype;
+} | {
+    type: 'methodHandle';
+    value: number;
+} | {
+    type: 'string';
+    value: string;
+} | {
+    type: 'type';
+    value: string;
+} | {
+    type: 'field';
+    value: DalvikExecutableField;
+} | {
+    type: 'method';
+    value: DalvikExecutableMethod;
+} | {
+    type: 'enum';
+    value: DalvikExecutableField;
+} | {
+    type: 'array';
+    value: DalvikExecutableEncodedValue[];
+} | {
+    type: 'annotation';
+    value: DalvikExecutableAnnotation;
+} | {
+    type: 'null';
+    value: null;
+} | {
+    type: 'boolean';
+    value: boolean;
+};
+type DalvikExecutableTry = {
+    startAddress: number;
+    instructionCount: number;
+    handler: DalvikExecutableEncodedCatchHandler;
+};
+type DalvikExecutableEncodedTypeAddressPair = {
+    type: string;
+    address: number;
+};
+type DalvikExecutableEncodedCatchHandler = {
+    handlers: DalvikExecutableEncodedTypeAddressPair[];
+    catchAllAddress: undefined | number;
+};
+export type DalvikExecutableCode<Instructions> = {
+    registersSize: number;
+    insSize: number;
+    outsSize: number;
+    debugInfo: undefined | DalvikExecutableDebugInfo;
+    instructions: Instructions;
+    tries: DalvikExecutableTry[];
+};
+type DalvikExecutableDebugByteCodeValue = {
+    type: 'advancePc';
+    addressDiff: number;
+} | {
+    type: 'advanceLine';
+    lineDiff: number;
+} | {
+    type: 'startLocal';
+    registerNum: number;
+    name: undefined | string;
+    type_: undefined | string;
+} | {
+    type: 'startLocalExtended';
+    registerNum: number;
+    name: undefined | string;
+    type_: undefined | string;
+    signature: undefined | string;
+} | {
+    type: 'endLocal';
+    registerNum: number;
+} | {
+    type: 'restartLocal';
+    registerNum: number;
+} | {
+    type: 'setPrologueEnd';
+} | {
+    type: 'setEpilogueBegin';
+} | {
+    type: 'setFile';
+    name: undefined | string;
+} | {
+    type: 'special';
+    value: number;
+};
+type DalvikExecutableDebugByteCode = DalvikExecutableDebugByteCodeValue[];
+export type DalvikExecutableDebugInfo = {
+    lineStart: number;
+    parameterNames: Array<undefined | string>;
+    bytecode: DalvikExecutableDebugByteCode;
+};
+type DalvikExecutableAnnotationItemVisibility = 'build' | 'runtime' | 'system';
+type DalvikExecutableAnnotationElement = {
+    name: string;
+    value: DalvikExecutableEncodedValue;
+};
+export type DalvikExecutableAnnotation = {
+    visibility: DalvikExecutableAnnotationItemVisibility;
+    type: string;
+    elements: DalvikExecutableAnnotationElement[];
+};
+export type DalvikExecutablePrototype = {
+    shorty: string;
+    returnType: string;
+    parameters: string[];
+};
+export type DalvikExecutableField = {
+    class: string;
+    type: string;
+    name: string;
+};
+export declare function isDalvikExecutableField(x: unknown): x is DalvikExecutableField;
+export declare function dalvikExecutableFieldEquals(a: DalvikExecutableField, b: DalvikExecutableField): boolean;
+export type DalvikExecutableFieldWithAccess = {
+    field: DalvikExecutableField;
+    accessFlags: DalvikExecutableAccessFlags;
+};
+export type DalvikExecutableMethod = {
+    class: string;
+    prototype: DalvikExecutablePrototype;
+    name: string;
+};
+export declare function isDalvikExecutableMethod(x: unknown): x is DalvikExecutableMethod;
+export declare function dalvikExecutableMethodEquals(a: DalvikExecutableMethod, b: DalvikExecutableMethod): boolean;
+export type DalvikExecutableMethodWithAccess<Instructions> = {
+    method: DalvikExecutableMethod;
+    accessFlags: DalvikExecutableAccessFlags;
+    code: undefined | DalvikExecutableCode<Instructions>;
+};
+export type DalvikExecutableClassFieldAnnotation = {
+    field: DalvikExecutableField;
+    annotations: undefined | DalvikExecutableAnnotation[];
+};
+export type DalvikExecutableClassMethodAnnotation = {
+    method: DalvikExecutableMethod;
+    annotations: DalvikExecutableAnnotation[];
+};
+export type DalvikExecutableClassParameterAnnotation = {
+    method: DalvikExecutableMethod;
+    annotations: DalvikExecutableAnnotation[][];
+};
+export type DalvikExecutableClassAnnotations = {
+    classAnnotations: DalvikExecutableAnnotation[];
+    fieldAnnotations: DalvikExecutableClassFieldAnnotation[];
+    methodAnnotations: DalvikExecutableClassMethodAnnotation[];
+    parameterAnnotations: DalvikExecutableClassParameterAnnotation[];
+};
+export type DalvikExecutableClassData<Instructions> = {
+    staticFields: DalvikExecutableFieldWithAccess[];
+    instanceFields: DalvikExecutableFieldWithAccess[];
+    directMethods: Array<DalvikExecutableMethodWithAccess<Instructions>>;
+    virtualMethods: Array<DalvikExecutableMethodWithAccess<Instructions>>;
+};
+export type DalvikExecutableClassDefinition<Instructions> = {
+    class: string;
+    accessFlags: DalvikExecutableAccessFlags;
+    superclass: string;
+    interfaces: string[];
+    sourceFile: undefined | string;
+    annotations: undefined | DalvikExecutableClassAnnotations;
+    staticValues: DalvikExecutableEncodedValue[];
+    classData: undefined | DalvikExecutableClassData<Instructions>;
+};
+export type DalvikExecutable<Instructions> = {
+    classDefinitions: Array<DalvikExecutableClassDefinition<Instructions>>;
+    link: undefined | Uint8Array;
+};
+export {};

package/build/dalvikExecutable.js

@@ -0,0 +1,56 @@
+export function dalvikExecutableAccessFlagsDefault() {
+    return {
+        public: false,
+        private: false,
+        protected: false,
+        static: false,
+        final: false,
+        synchronized: false,
+        volatile: false,
+        bridge: false,
+        transient: false,
+        varargs: false,
+        native: false,
+        interface: false,
+        abstract: false,
+        strict: false,
+        synthetic: false,
+        annotation: false,
+        enum: false,
+        constructor: false,
+        declaredSynchronized: false,
+    };
+}
+export function isDalvikExecutableField(x) {
+    return (x !== null
+        && typeof x === 'object'
+        && 'class' in x
+        && 'type' in x
+        && 'name' in x
+        && typeof x.class === 'string'
+        && typeof x.type === 'string'
+        && typeof x.name === 'string');
+}
+export function dalvikExecutableFieldEquals(a, b) {
+    return (a.class === b.class
+        && a.type === b.type
+        && a.name === b.name);
+}
+export function isDalvikExecutableMethod(x) {
+    return (x !== null
+        && typeof x === 'object'
+        && 'class' in x
+        && 'prototype' in x
+        && 'name' in x
+        && typeof x.class === 'string'
+        && typeof x.prototype === 'object'
+        && typeof x.name === 'string');
+}
+export function dalvikExecutableMethodEquals(a, b) {
+    return (a.class === b.class
+        && a.name === b.name
+        && a.prototype.shorty === b.prototype.shorty
+        && a.prototype.returnType === b.prototype.returnType
+        && a.prototype.parameters.length === b.prototype.parameters.length
+        && a.prototype.parameters.every((v, i) => v === b.prototype.parameters[i]));
+}

package/build/dalvikExecutableParser/stringSyntaxParser.d.ts

@@ -0,0 +1,4 @@
+import { type Parser } from '../parser.js';
+export declare const smaliSimpleNameParser: Parser<string, string>;
+export declare const smaliMemberNameParser: Parser<string, string>;
+export declare const smaliTypeDescriptorParser: Parser<string, string>;

package/build/dalvikExecutableParser/stringSyntaxParser.js

@@ -0,0 +1,76 @@
+import invariant from 'invariant';
+import { setParserName } from '../parser.js';
+import { promiseCompose } from '../promiseCompose.js';
+import { createSeparatedArrayParser } from '../separatedArrayParser.js';
+import { createExactSequenceParser } from '../exactSequenceParser.js';
+import { createUnionParser } from '../unionParser.js';
+import { createTupleParser } from '../tupleParser.js';
+import { createArrayParser } from '../arrayParser.js';
+export const smaliSimpleNameParser = async (parserContext) => {
+    const characters = [];
+    while (true) {
+        const character = await parserContext.peek(0);
+        parserContext.invariant(character !== undefined, 'Unexpected end of input');
+        invariant(character !== undefined, 'Unexpected end of input');
+        if ((character >= 'a' && character <= 'z')
+            || (character >= 'A' && character <= 'Z')
+            || (character >= '0' && character <= '9')
+            || (character === ' ')
+            || (character === '$')
+            || (character === '-')
+            || (character === '_')
+            || (character === '\u00A0')
+            || (character >= '\u00A1' && character <= '\u1FFF')
+            || (character >= '\u2000' && character <= '\u200A')
+            || (character >= '\u2010' && character <= '\u2027')
+            || (character === '\u202F')
+            || (character >= '\u2030' && character <= '\uD7FF')
+            || (character >= '\uE000' && character <= '\uFFEF')
+            || (character >= '\uD800' && character <= '\uDBFF')) {
+            parserContext.skip(1);
+            characters.push(character);
+            continue;
+        }
+        parserContext.invariant(characters.length > 0, 'Expected at least one character');
+        break;
+    }
+    return characters.join('');
+};
+setParserName(smaliSimpleNameParser, 'smaliSimpleNameParser');
+export const smaliMemberNameParser = createUnionParser([
+    smaliSimpleNameParser,
+    promiseCompose(createTupleParser([
+        createExactSequenceParser('<'),
+        smaliSimpleNameParser,
+        createExactSequenceParser('>'),
+    ]), strings => strings.join('')),
+]);
+setParserName(smaliMemberNameParser, 'smaliMemberNameParser');
+const smaliFullClassNameParser = promiseCompose(createSeparatedArrayParser(smaliMemberNameParser, createExactSequenceParser('/')), pathSegments => pathSegments.join('/'));
+setParserName(smaliFullClassNameParser, 'smaliFullClassNameParser');
+const smaliNonArrayFieldTypeDescriptorParser = createUnionParser([
+    createExactSequenceParser('Z'),
+    createExactSequenceParser('B'),
+    createExactSequenceParser('S'),
+    createExactSequenceParser('C'),
+    createExactSequenceParser('I'),
+    createExactSequenceParser('J'),
+    createExactSequenceParser('F'),
+    createExactSequenceParser('D'),
+    promiseCompose(createTupleParser([
+        createExactSequenceParser('L'),
+        smaliFullClassNameParser,
+        createExactSequenceParser(';'),
+    ]), strings => strings.join('')),
+]);
+setParserName(smaliNonArrayFieldTypeDescriptorParser, 'smaliNonArrayFieldTypeDescriptorParser');
+const smaliFieldTypeDescriptorParser = promiseCompose(createTupleParser([
+    createArrayParser(createExactSequenceParser('[')),
+    smaliNonArrayFieldTypeDescriptorParser,
+]), ([strings, string]) => strings.join('') + string);
+setParserName(smaliFieldTypeDescriptorParser, 'smaliFieldTypeDescriptorParser');
+export const smaliTypeDescriptorParser = createUnionParser([
+    createExactSequenceParser('V'),
+    smaliFieldTypeDescriptorParser,
+]);
+setParserName(smaliTypeDescriptorParser, 'smaliTypeDescriptorParser');

package/build/dalvikExecutableParser/typeParsers.d.ts

@@ -0,0 +1,11 @@
+import { type Parser } from '../parser.js';
+export declare const uleb128p1NumberParser: Parser<number, Uint8Array>;
+export declare const ubyteParser: Parser<number, Uint8Array>;
+export declare const byteParser: Parser<number, Uint8Array>;
+export declare const shortParser: Parser<number, Uint8Array>;
+export declare const ushortParser: Parser<number, Uint8Array>;
+export declare const createExactUshortParser: (expectedValue: number) => Parser<number, Uint8Array>;
+export declare const intParser: Parser<number, Uint8Array>;
+export declare const uintParser: Parser<number, Uint8Array>;
+export declare const longParser: Parser<bigint, Uint8Array>;
+export declare const ulongParser: Parser<bigint, Uint8Array>;

package/build/dalvikExecutableParser/typeParsers.js

@@ -0,0 +1,39 @@
+import { createElementParser } from '../elementParser.js';
+import { createFixedLengthSequenceParser } from '../fixedLengthSequenceParser.js';
+import { uleb128NumberParser } from '../leb128Parser.js';
+import { parserCreatorCompose } from '../parserCreatorCompose.js';
+import { promiseCompose } from '../promiseCompose.js';
+export const uleb128p1NumberParser = async (parserContext) => {
+    const value = await uleb128NumberParser(parserContext);
+    return value - 1;
+};
+export const ubyteParser = createElementParser();
+export const byteParser = promiseCompose(ubyteParser, ubyte => ubyte > 127 ? ubyte - 256 : ubyte);
+export const shortParser = promiseCompose(createFixedLengthSequenceParser(2), uint8Array => {
+    const buffer = Buffer.from(uint8Array);
+    return buffer.readInt16LE(0);
+});
+export const ushortParser = promiseCompose(createFixedLengthSequenceParser(2), uint8Array => {
+    const buffer = Buffer.from(uint8Array);
+    return buffer.readUInt16LE(0);
+});
+export const createExactUshortParser = (expectedValue) => parserCreatorCompose(() => ushortParser, ushortValue => async (parserContext) => {
+    parserContext.invariant(ushortValue === expectedValue, `Expected ushort value ${expectedValue}, got ${ushortValue}`);
+    return ushortValue;
+})();
+export const intParser = promiseCompose(createFixedLengthSequenceParser(4), uint8Array => {
+    const buffer = Buffer.from(uint8Array);
+    return buffer.readInt32LE(0);
+});
+export const uintParser = promiseCompose(createFixedLengthSequenceParser(4), uint8Array => {
+    const buffer = Buffer.from(uint8Array);
+    return buffer.readUInt32LE(0);
+});
+export const longParser = promiseCompose(createFixedLengthSequenceParser(8), uint8Array => {
+    const buffer = Buffer.from(uint8Array);
+    return buffer.readBigInt64LE(0);
+});
+export const ulongParser = promiseCompose(createFixedLengthSequenceParser(8), uint8Array => {
+    const buffer = Buffer.from(uint8Array);
+    return buffer.readBigUInt64LE(0);
+});

package/build/dalvikExecutableParser/typedNumbers.d.ts

@@ -0,0 +1,106 @@
+import { type Newtype } from 'newtype-ts';
+export type IndexIntoStringIds = {} & Newtype<{
+    readonly IndexIntoStringIds: unique symbol;
+}, number>;
+export declare const isoIndexIntoStringIds: import("monocle-ts").Iso<Newtype<{
+    readonly IndexIntoStringIds: unique symbol;
+}, number>, number>;
+export type IndexIntoTypeIds = {} & Newtype<{
+    readonly IndexIntoTypeIds: unique symbol;
+}, number>;
+export declare const isoIndexIntoTypeIds: import("monocle-ts").Iso<Newtype<{
+    readonly IndexIntoTypeIds: unique symbol;
+}, number>, number>;
+export type IndexIntoPrototypeIds = {} & Newtype<{
+    readonly IndexIntoPrototypeIds: unique symbol;
+}, number>;
+export declare const isoIndexIntoPrototypeIds: import("monocle-ts").Iso<Newtype<{
+    readonly IndexIntoPrototypeIds: unique symbol;
+}, number>, number>;
+export type IndexIntoFieldIds = {} & Newtype<{
+    readonly IndexIntoFieldIds: unique symbol;
+}, number>;
+export declare const isoIndexIntoFieldIds: import("monocle-ts").Iso<Newtype<{
+    readonly IndexIntoFieldIds: unique symbol;
+}, number>, number>;
+export type IndexIntoMethodIds = {} & Newtype<{
+    readonly IndexIntoMethodIds: unique symbol;
+}, number>;
+export declare const isoIndexIntoMethodIds: import("monocle-ts").Iso<Newtype<{
+    readonly IndexIntoMethodIds: unique symbol;
+}, number>, number>;
+export type OffsetToStringDataItem = {} & Newtype<{
+    readonly OffsetToStringDataItem: unique symbol;
+}, number>;
+export declare const isoOffsetToStringDataItem: import("monocle-ts").Iso<Newtype<{
+    readonly OffsetToStringDataItem: unique symbol;
+}, number>, number>;
+export type OffsetToTypeList = {} & Newtype<{
+    readonly OffsetToTypeList: unique symbol;
+}, number>;
+export declare const isoOffsetToTypeList: import("monocle-ts").Iso<Newtype<{
+    readonly OffsetToTypeList: unique symbol;
+}, number>, number>;
+export type OffsetToAnnotationsDirectoryItem = {} & Newtype<{
+    readonly OffsetToAnnotationsDirectoryItem: unique symbol;
+}, number>;
+export declare const isoOffsetToAnnotationsDirectoryItem: import("monocle-ts").Iso<Newtype<{
+    readonly OffsetToAnnotationsDirectoryItem: unique symbol;
+}, number>, number>;
+export type OffsetToAnnotationSetItem = {} & Newtype<{
+    readonly OffsetToAnnotationSetItem: unique symbol;
+}, number>;
+export declare const isoOffsetToAnnotationSetItem: import("monocle-ts").Iso<Newtype<{
+    readonly OffsetToAnnotationSetItem: unique symbol;
+}, number>, number>;
+export type OffsetToAnnotationSetRefListItem = {} & Newtype<{
+    readonly OffsetToAnnotationSetRefListItem: unique symbol;
+}, number>;
+export declare const isoOffsetToAnnotationSetRefListItem: import("monocle-ts").Iso<Newtype<{
+    readonly OffsetToAnnotationSetRefListItem: unique symbol;
+}, number>, number>;
+export type OffsetToClassDataItem = {} & Newtype<{
+    readonly OffsetToClassDataItem: unique symbol;
+}, number>;
+export declare const isoOffsetToClassDataItem: import("monocle-ts").Iso<Newtype<{
+    readonly OffsetToClassDataItem: unique symbol;
+}, number>, number>;
+export type OffsetToEncodedArrayItem = {} & Newtype<{
+    readonly OffsetToEncodedArrayItem: unique symbol;
+}, number>;
+export declare const isoOffsetToEncodedArrayItem: import("monocle-ts").Iso<Newtype<{
+    readonly OffsetToEncodedArrayItem: unique symbol;
+}, number>, number>;
+export type OffsetToCodeItem = {} & Newtype<{
+    readonly OffsetToCodeItem: unique symbol;
+}, number>;
+export declare const isoOffsetToCodeItem: import("monocle-ts").Iso<Newtype<{
+    readonly OffsetToCodeItem: unique symbol;
+}, number>, number>;
+export type OffsetToDebugInfoItem = {} & Newtype<{
+    readonly OffsetToDebugInfoItem: unique symbol;
+}, number>;
+export declare const isoOffsetToDebugInfoItem: import("monocle-ts").Iso<Newtype<{
+    readonly OffsetToDebugInfoItem: unique symbol;
+}, number>, number>;
+export type OffsetToAnnotationItem = {} & Newtype<{
+    readonly OffsetToAnnotationItem: unique symbol;
+}, number>;
+export declare const isoOffsetToAnnotationItem: import("monocle-ts").Iso<Newtype<{
+    readonly OffsetToAnnotationItem: unique symbol;
+}, number>, number>;
+export type OffsetFromEncodedCatchHandlerListToEncodedCatchHandler = {} & Newtype<{
+    readonly OffsetFromEncodedCatchHandlerListToEncodedCatchHandler: unique symbol;
+}, number>;
+export declare const isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler: import("monocle-ts").Iso<Newtype<{
+    readonly OffsetFromEncodedCatchHandlerListToEncodedCatchHandler: unique symbol;
+}, number>, number>;
+export type TypedNumberArray<IndexType, ValueType> = {
+    get length(): number;
+    at(index: IndexType): undefined | ValueType;
+    map<NewValueType>(fn: (value: ValueType, index: IndexType) => NewValueType): TypedNumberArray<IndexType, NewValueType>;
+    [Symbol.iterator](): IterableIterator<ValueType>;
+} & Newtype<{
+    readonly TypedNumberArray: unique symbol;
+}, ValueType[]>;
+export declare const getIsoTypedNumberArray: <IndexType, ValueType>() => import("monocle-ts").Iso<TypedNumberArray<IndexType, ValueType>, ValueType[]>;

package/build/dalvikExecutableParser/typedNumbers.js

@@ -0,0 +1,18 @@
+import { iso } from 'newtype-ts';
+export const isoIndexIntoStringIds = iso();
+export const isoIndexIntoTypeIds = iso();
+export const isoIndexIntoPrototypeIds = iso();
+export const isoIndexIntoFieldIds = iso();
+export const isoIndexIntoMethodIds = iso();
+export const isoOffsetToStringDataItem = iso();
+export const isoOffsetToTypeList = iso();
+export const isoOffsetToAnnotationsDirectoryItem = iso();
+export const isoOffsetToAnnotationSetItem = iso();
+export const isoOffsetToAnnotationSetRefListItem = iso();
+export const isoOffsetToClassDataItem = iso();
+export const isoOffsetToEncodedArrayItem = iso();
+export const isoOffsetToCodeItem = iso();
+export const isoOffsetToDebugInfoItem = iso();
+export const isoOffsetToAnnotationItem = iso();
+export const isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler = iso();
+export const getIsoTypedNumberArray = () => iso();

package/build/dalvikExecutableParser.d.ts

@@ -0,0 +1,5 @@
+import { type Parser } from './parser.js';
+import { type DalvikBytecode } from './dalvikBytecodeParser.js';
+import { type DalvikExecutable } from './dalvikExecutable.js';
+export declare const dalvikExecutableParser: Parser<DalvikExecutable<DalvikBytecode>, Uint8Array>;
+export declare const dalvikExecutableWithRawInstructionsParser: Parser<DalvikExecutable<Uint8Array>, Uint8Array>;