@futpib/parser 1.0.1 → 1.0.2

package/build/dalvikExecutable.d.ts

@@ -0,0 +1,158 @@
+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 type DalvikExecutableEncodedValue = number | DalvikExecutableEncodedValue[] | undefined;
+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: (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 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 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: undefined | DalvikExecutableAnnotation[];
+};
+export type DalvikExecutableClassParameterAnnotation = {
+    method: DalvikExecutableMethod;
+    annotations: undefined | (undefined | DalvikExecutableAnnotation[])[];
+};
+export type DalvikExecutableClassAnnotations = {
+    classAnnotations: undefined | DalvikExecutableAnnotation[];
+    fieldAnnotations: DalvikExecutableClassFieldAnnotation[];
+    methodAnnotations: DalvikExecutableClassMethodAnnotation[];
+    parameterAnnotations: DalvikExecutableClassParameterAnnotation[];
+};
+export type DalvikExecutableClassData<Instructions> = {
+    staticFields: DalvikExecutableFieldWithAccess[];
+    instanceFields: DalvikExecutableFieldWithAccess[];
+    directMethods: DalvikExecutableMethodWithAccess<Instructions>[];
+    virtualMethods: 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: DalvikExecutableClassDefinition<Instructions>[];
+    link: undefined | Uint8Array;
+};
+export {};

package/build/dalvikExecutable.js

@@ -0,0 +1,20 @@
+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 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');
+}

package/build/dalvikExecutableParser/stringSyntaxParser.d.ts

@@ -0,0 +1,4 @@
+import { 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,10 @@
+import { 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 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,34 @@
+import { createElementParser } from "../elementParser.js";
+import { createFixedLengthSequenceParser } from "../fixedLengthSequenceParser.js";
+import { uleb128NumberParser } from "../leb128Parser.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 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,90 @@
+import { Newtype } from 'newtype-ts';
+export interface IndexIntoStringIds extends Newtype<{
+    readonly IndexIntoStringIds: unique symbol;
+}, number> {
+}
+export declare const isoIndexIntoStringIds: import("monocle-ts").Iso<IndexIntoStringIds, number>;
+export interface IndexIntoTypeIds extends Newtype<{
+    readonly IndexIntoTypeIds: unique symbol;
+}, number> {
+}
+export declare const isoIndexIntoTypeIds: import("monocle-ts").Iso<IndexIntoTypeIds, number>;
+export interface IndexIntoPrototypeIds extends Newtype<{
+    readonly IndexIntoPrototypeIds: unique symbol;
+}, number> {
+}
+export declare const isoIndexIntoPrototypeIds: import("monocle-ts").Iso<IndexIntoPrototypeIds, number>;
+export interface IndexIntoFieldIds extends Newtype<{
+    readonly IndexIntoFieldIds: unique symbol;
+}, number> {
+}
+export declare const isoIndexIntoFieldIds: import("monocle-ts").Iso<IndexIntoFieldIds, number>;
+export interface IndexIntoMethodIds extends Newtype<{
+    readonly IndexIntoMethodIds: unique symbol;
+}, number> {
+}
+export declare const isoIndexIntoMethodIds: import("monocle-ts").Iso<IndexIntoMethodIds, number>;
+export interface OffsetToStringDataItem extends Newtype<{
+    readonly OffsetToStringDataItem: unique symbol;
+}, number> {
+}
+export declare const isoOffsetToStringDataItem: import("monocle-ts").Iso<OffsetToStringDataItem, number>;
+export interface OffsetToTypeList extends Newtype<{
+    readonly OffsetToTypeList: unique symbol;
+}, number> {
+}
+export declare const isoOffsetToTypeList: import("monocle-ts").Iso<OffsetToTypeList, number>;
+export interface OffsetToAnnotationsDirectoryItem extends Newtype<{
+    readonly OffsetToAnnotationsDirectoryItem: unique symbol;
+}, number> {
+}
+export declare const isoOffsetToAnnotationsDirectoryItem: import("monocle-ts").Iso<OffsetToAnnotationsDirectoryItem, number>;
+export interface OffsetToAnnotationSetItem extends Newtype<{
+    readonly OffsetToAnnotationSetItem: unique symbol;
+}, number> {
+}
+export declare const isoOffsetToAnnotationSetItem: import("monocle-ts").Iso<OffsetToAnnotationSetItem, number>;
+export interface OffsetToAnnotationSetRefListItem extends Newtype<{
+    readonly OffsetToAnnotationSetRefListItem: unique symbol;
+}, number> {
+}
+export declare const isoOffsetToAnnotationSetRefListItem: import("monocle-ts").Iso<OffsetToAnnotationSetRefListItem, number>;
+export interface OffsetToClassDataItem extends Newtype<{
+    readonly OffsetToClassDataItem: unique symbol;
+}, number> {
+}
+export declare const isoOffsetToClassDataItem: import("monocle-ts").Iso<OffsetToClassDataItem, number>;
+export interface OffsetToEncodedArrayItem extends Newtype<{
+    readonly OffsetToEncodedArrayItem: unique symbol;
+}, number> {
+}
+export declare const isoOffsetToEncodedArrayItem: import("monocle-ts").Iso<OffsetToEncodedArrayItem, number>;
+export interface OffsetToCodeItem extends Newtype<{
+    readonly OffsetToCodeItem: unique symbol;
+}, number> {
+}
+export declare const isoOffsetToCodeItem: import("monocle-ts").Iso<OffsetToCodeItem, number>;
+export interface OffsetToDebugInfoItem extends Newtype<{
+    readonly OffsetToDebugInfoItem: unique symbol;
+}, number> {
+}
+export declare const isoOffsetToDebugInfoItem: import("monocle-ts").Iso<OffsetToDebugInfoItem, number>;
+export interface OffsetToAnnotationItem extends Newtype<{
+    readonly OffsetToAnnotationItem: unique symbol;
+}, number> {
+}
+export declare const isoOffsetToAnnotationItem: import("monocle-ts").Iso<OffsetToAnnotationItem, number>;
+export interface OffsetFromEncodedCatchHandlerListToEncodedCatchHandler extends Newtype<{
+    readonly OffsetFromEncodedCatchHandlerListToEncodedCatchHandler: unique symbol;
+}, number> {
+}
+export declare const isoOffsetFromEncodedCatchHandlerListToEncodedCatchHandler: import("monocle-ts").Iso<OffsetFromEncodedCatchHandlerListToEncodedCatchHandler, number>;
+export interface TypedNumberArray<IndexType, ValueType> extends Newtype<{
+    readonly TypedNumberArray: unique symbol;
+}, Array<ValueType>> {
+    get length(): number;
+    at(index: IndexType): undefined | ValueType;
+    map<NewValueType>(fn: (value: ValueType, index: IndexType) => NewValueType): TypedNumberArray<IndexType, NewValueType>;
+    [Symbol.iterator](): IterableIterator<ValueType>;
+}
+export declare const getIsoTypedNumberArray: <IndexType, ValueType>() => import("monocle-ts").Iso<TypedNumberArray<IndexType, ValueType>, ValueType[]>;

package/build/dalvikExecutableParser/typedNumbers.js

@@ -0,0 +1,19 @@
+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 { DalvikBytecode } from './dalvikBytecodeParser.js';
+import { DalvikExecutable } from './dalvikExecutable.js';
+export declare const dalvikExecutableParser: Parser<DalvikExecutable<DalvikBytecode>, Uint8Array>;
+export declare const dalvikExecutableWithRawInstructionsParser: Parser<DalvikExecutable<Uint8Array>, Uint8Array>;