@futpib/parser 1.0.2 → 1.0.4

package/build/dalvikExecutable.d.ts

@@ -19,7 +19,62 @@ export type DalvikExecutableAccessFlags = {
     constructor: boolean;
     declaredSynchronized: boolean;
 };
-export type DalvikExecutableEncodedValue = number | DalvikExecutableEncodedValue[] | undefined;
+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;
@@ -78,7 +133,7 @@ type DalvikExecutableDebugByteCodeValue = {
 type DalvikExecutableDebugByteCode = DalvikExecutableDebugByteCodeValue[];
 export type DalvikExecutableDebugInfo = {
     lineStart: number;
-    parameterNames: (undefined | string)[];
+    parameterNames: Array<undefined | string>;
     bytecode: DalvikExecutableDebugByteCode;
 };
 type DalvikExecutableAnnotationItemVisibility = 'build' | 'runtime' | 'system';
@@ -102,6 +157,7 @@ export type DalvikExecutableField = {
     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;
@@ -112,6 +168,7 @@ export type DalvikExecutableMethod = {
     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;
@@ -123,14 +180,14 @@ export type DalvikExecutableClassFieldAnnotation = {
 };
 export type DalvikExecutableClassMethodAnnotation = {
     method: DalvikExecutableMethod;
-    annotations: undefined | DalvikExecutableAnnotation[];
+    annotations: DalvikExecutableAnnotation[];
 };
 export type DalvikExecutableClassParameterAnnotation = {
     method: DalvikExecutableMethod;
-    annotations: undefined | (undefined | DalvikExecutableAnnotation[])[];
+    annotations: DalvikExecutableAnnotation[][];
 };
 export type DalvikExecutableClassAnnotations = {
-    classAnnotations: undefined | DalvikExecutableAnnotation[];
+    classAnnotations: DalvikExecutableAnnotation[];
     fieldAnnotations: DalvikExecutableClassFieldAnnotation[];
     methodAnnotations: DalvikExecutableClassMethodAnnotation[];
     parameterAnnotations: DalvikExecutableClassParameterAnnotation[];
@@ -138,8 +195,8 @@ export type DalvikExecutableClassAnnotations = {
 export type DalvikExecutableClassData<Instructions> = {
     staticFields: DalvikExecutableFieldWithAccess[];
     instanceFields: DalvikExecutableFieldWithAccess[];
-    directMethods: DalvikExecutableMethodWithAccess<Instructions>[];
-    virtualMethods: DalvikExecutableMethodWithAccess<Instructions>[];
+    directMethods: Array<DalvikExecutableMethodWithAccess<Instructions>>;
+    virtualMethods: Array<DalvikExecutableMethodWithAccess<Instructions>>;
 };
 export type DalvikExecutableClassDefinition<Instructions> = {
     class: string;
@@ -152,7 +209,7 @@ export type DalvikExecutableClassDefinition<Instructions> = {
     classData: undefined | DalvikExecutableClassData<Instructions>;
 };
 export type DalvikExecutable<Instructions> = {
-    classDefinitions: DalvikExecutableClassDefinition<Instructions>[];
+    classDefinitions: Array<DalvikExecutableClassDefinition<Instructions>>;
     link: undefined | Uint8Array;
 };
 export {};

package/build/dalvikExecutable.js

@@ -1,3 +1,26 @@
+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'
@@ -8,6 +31,11 @@ export function isDalvikExecutableField(x) {
         && 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'
@@ -18,3 +46,11 @@ export function isDalvikExecutableMethod(x) {
         && 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

@@ -1,4 +1,4 @@
-import { Parser } from "../parser.js";
+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

@@ -1,11 +1,11 @@
-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";
+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) {
@@ -19,14 +19,14 @@ export const smaliSimpleNameParser = async (parserContext) => {
             || (character === '$')
             || (character === '-')
             || (character === '_')
-            || (character === '\u00a0')
-            || (character >= '\u00a1' && character <= '\u1fff')
-            || (character >= '\u2000' && character <= '\u200a')
+            || (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')) {
+            || (character === '\u202F')
+            || (character >= '\u2030' && character <= '\uD7FF')
+            || (character >= '\uE000' && character <= '\uFFEF')
+            || (character >= '\uD800' && character <= '\uDBFF')) {
             parserContext.skip(1);
             characters.push(character);
             continue;
@@ -43,10 +43,10 @@ export const smaliMemberNameParser = createUnionParser([
         createExactSequenceParser('<'),
         smaliSimpleNameParser,
         createExactSequenceParser('>'),
-    ]), (strings) => strings.join('')),
+    ]), strings => strings.join('')),
 ]);
 setParserName(smaliMemberNameParser, 'smaliMemberNameParser');
-const smaliFullClassNameParser = promiseCompose(createSeparatedArrayParser(smaliMemberNameParser, createExactSequenceParser('/')), (pathSegments) => pathSegments.join('/'));
+const smaliFullClassNameParser = promiseCompose(createSeparatedArrayParser(smaliMemberNameParser, createExactSequenceParser('/')), pathSegments => pathSegments.join('/'));
 setParserName(smaliFullClassNameParser, 'smaliFullClassNameParser');
 const smaliNonArrayFieldTypeDescriptorParser = createUnionParser([
     createExactSequenceParser('Z'),

package/build/dalvikExecutableParser/typeParsers.d.ts

@@ -1,9 +1,10 @@
-import { Parser } from "../parser.js";
+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>;

package/build/dalvikExecutableParser/typeParsers.js

@@ -1,34 +1,39 @@
-import { createElementParser } from "../elementParser.js";
-import { createFixedLengthSequenceParser } from "../fixedLengthSequenceParser.js";
-import { uleb128NumberParser } from "../leb128Parser.js";
-import { promiseCompose } from "../promiseCompose.js";
+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) => {
+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) => {
+export const ushortParser = promiseCompose(createFixedLengthSequenceParser(2), uint8Array => {
     const buffer = Buffer.from(uint8Array);
     return buffer.readUInt16LE(0);
 });
-export const intParser = promiseCompose(createFixedLengthSequenceParser(4), (uint8Array) => {
+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) => {
+export const uintParser = promiseCompose(createFixedLengthSequenceParser(4), uint8Array => {
     const buffer = Buffer.from(uint8Array);
     return buffer.readUInt32LE(0);
 });
-export const longParser = promiseCompose(createFixedLengthSequenceParser(8), (uint8Array) => {
+export const longParser = promiseCompose(createFixedLengthSequenceParser(8), uint8Array => {
     const buffer = Buffer.from(uint8Array);
     return buffer.readBigInt64LE(0);
 });
-export const ulongParser = promiseCompose(createFixedLengthSequenceParser(8), (uint8Array) => {
+export const ulongParser = promiseCompose(createFixedLengthSequenceParser(8), uint8Array => {
     const buffer = Buffer.from(uint8Array);
     return buffer.readBigUInt64LE(0);
 });

package/build/dalvikExecutableParser/typedNumbers.d.ts

@@ -1,90 +1,106 @@
-import { Newtype } from 'newtype-ts';
-export interface IndexIntoStringIds extends Newtype<{
+import { type Newtype } from 'newtype-ts';
+export type IndexIntoStringIds = {} & Newtype<{
     readonly IndexIntoStringIds: unique symbol;
-}, number> {
-}
-export declare const isoIndexIntoStringIds: import("monocle-ts").Iso<IndexIntoStringIds, number>;
-export interface IndexIntoTypeIds extends Newtype<{
+}, 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> {
-}
-export declare const isoIndexIntoTypeIds: import("monocle-ts").Iso<IndexIntoTypeIds, number>;
-export interface IndexIntoPrototypeIds extends Newtype<{
+}, 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> {
-}
-export declare const isoIndexIntoPrototypeIds: import("monocle-ts").Iso<IndexIntoPrototypeIds, number>;
-export interface IndexIntoFieldIds extends Newtype<{
+}, number>, number>;
+export type IndexIntoFieldIds = {} & Newtype<{
     readonly IndexIntoFieldIds: unique symbol;
-}, number> {
-}
-export declare const isoIndexIntoFieldIds: import("monocle-ts").Iso<IndexIntoFieldIds, number>;
-export interface IndexIntoMethodIds extends Newtype<{
+}, 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> {
-}
-export declare const isoIndexIntoMethodIds: import("monocle-ts").Iso<IndexIntoMethodIds, number>;
-export interface OffsetToStringDataItem extends Newtype<{
+}, number>, number>;
+export type OffsetToStringDataItem = {} & Newtype<{
     readonly OffsetToStringDataItem: unique symbol;
-}, number> {
-}
-export declare const isoOffsetToStringDataItem: import("monocle-ts").Iso<OffsetToStringDataItem, number>;
-export interface OffsetToTypeList extends Newtype<{
+}, 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> {
-}
-export declare const isoOffsetToTypeList: import("monocle-ts").Iso<OffsetToTypeList, number>;
-export interface OffsetToAnnotationsDirectoryItem extends Newtype<{
+}, number>, number>;
+export type OffsetToAnnotationsDirectoryItem = {} & Newtype<{
     readonly OffsetToAnnotationsDirectoryItem: unique symbol;
-}, number> {
-}
-export declare const isoOffsetToAnnotationsDirectoryItem: import("monocle-ts").Iso<OffsetToAnnotationsDirectoryItem, number>;
-export interface OffsetToAnnotationSetItem extends Newtype<{
+}, 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> {
-}
-export declare const isoOffsetToAnnotationSetItem: import("monocle-ts").Iso<OffsetToAnnotationSetItem, number>;
-export interface OffsetToAnnotationSetRefListItem extends Newtype<{
+}, number>, number>;
+export type OffsetToAnnotationSetRefListItem = {} & Newtype<{
     readonly OffsetToAnnotationSetRefListItem: unique symbol;
-}, number> {
-}
-export declare const isoOffsetToAnnotationSetRefListItem: import("monocle-ts").Iso<OffsetToAnnotationSetRefListItem, number>;
-export interface OffsetToClassDataItem extends Newtype<{
+}, 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> {
-}
-export declare const isoOffsetToClassDataItem: import("monocle-ts").Iso<OffsetToClassDataItem, number>;
-export interface OffsetToEncodedArrayItem extends Newtype<{
+}, 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> {
-}
-export declare const isoOffsetToEncodedArrayItem: import("monocle-ts").Iso<OffsetToEncodedArrayItem, number>;
-export interface OffsetToCodeItem extends Newtype<{
+}, number>, number>;
+export type OffsetToCodeItem = {} & Newtype<{
     readonly OffsetToCodeItem: unique symbol;
-}, number> {
-}
-export declare const isoOffsetToCodeItem: import("monocle-ts").Iso<OffsetToCodeItem, number>;
-export interface OffsetToDebugInfoItem extends Newtype<{
+}, 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> {
-}
-export declare const isoOffsetToDebugInfoItem: import("monocle-ts").Iso<OffsetToDebugInfoItem, number>;
-export interface OffsetToAnnotationItem extends Newtype<{
+}, number>, number>;
+export type OffsetToAnnotationItem = {} & Newtype<{
     readonly OffsetToAnnotationItem: unique symbol;
-}, number> {
-}
-export declare const isoOffsetToAnnotationItem: import("monocle-ts").Iso<OffsetToAnnotationItem, number>;
-export interface OffsetFromEncodedCatchHandlerListToEncodedCatchHandler extends Newtype<{
+}, 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<OffsetFromEncodedCatchHandlerListToEncodedCatchHandler, number>;
-export interface TypedNumberArray<IndexType, ValueType> extends Newtype<{
-    readonly TypedNumberArray: unique symbol;
-}, Array<ValueType>> {
+}, 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

@@ -15,5 +15,4 @@ 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

@@ -1,5 +1,5 @@
 import { type Parser } from './parser.js';
-import { DalvikBytecode } from './dalvikBytecodeParser.js';
-import { DalvikExecutable } from './dalvikExecutable.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>;