swf-toolkit 0.0.0-stage → 0.1.0

package/dist/abc/constants.d.ts

@@ -0,0 +1,80 @@
+/** Namespace kinds (AVM2 overview §4.4.1). */
+export declare const NamespaceKind: {
+    readonly Namespace: 8;
+    readonly PackageNamespace: 22;
+    readonly PackageInternalNs: 23;
+    readonly ProtectedNamespace: 24;
+    readonly ExplicitNamespace: 25;
+    readonly StaticProtectedNs: 26;
+    readonly PrivateNs: 5;
+};
+/** Multiname kinds (AVM2 overview §4.4.3). */
+export declare const MultinameKind: {
+    readonly QName: 7;
+    readonly QNameA: 13;
+    readonly RTQName: 15;
+    readonly RTQNameA: 16;
+    readonly RTQNameL: 17;
+    readonly RTQNameLA: 18;
+    readonly Multiname: 9;
+    readonly MultinameA: 14;
+    readonly MultinameL: 27;
+    readonly MultinameLA: 28;
+    /** Parameterised type, e.g. Vector.<int>. */
+    readonly TypeName: 29;
+};
+/** Constant value kinds used for optional parameters and slot defaults. */
+export declare const ConstantKind: {
+    readonly Undefined: 0;
+    readonly Utf8: 1;
+    readonly Decimal: 2;
+    readonly Int: 3;
+    readonly UInt: 4;
+    readonly PrivateNs: 5;
+    readonly Double: 6;
+    readonly Namespace: 8;
+    readonly False: 10;
+    readonly True: 11;
+    readonly Null: 12;
+    readonly PackageNamespace: 22;
+    readonly PackageInternalNs: 23;
+    readonly ProtectedNamespace: 24;
+    readonly ExplicitNamespace: 25;
+    readonly StaticProtectedNs: 26;
+};
+export declare const MethodFlags: {
+    readonly NEED_ARGUMENTS: 1;
+    readonly NEED_ACTIVATION: 2;
+    readonly NEED_REST: 4;
+    readonly HAS_OPTIONAL: 8;
+    readonly IGNORE_REST: 16;
+    readonly EXPLICIT: 32;
+    readonly SET_DXNS: 64;
+    readonly HAS_PARAM_NAMES: 128;
+};
+export declare const InstanceFlags: {
+    readonly Sealed: 1;
+    readonly Final: 2;
+    readonly Interface: 4;
+    readonly ProtectedNs: 8;
+};
+export declare const TraitKind: {
+    readonly Slot: 0;
+    readonly Method: 1;
+    readonly Getter: 2;
+    readonly Setter: 3;
+    readonly Class: 4;
+    readonly Function: 5;
+    readonly Const: 6;
+};
+export declare const TraitAttr: {
+    readonly Final: 1;
+    readonly Override: 2;
+    readonly Metadata: 4;
+};
+export declare const NAMESPACE_KIND_NAMES: Map<number, string>;
+export declare const NAMESPACE_KIND_BY_NAME: Map<string, number>;
+export declare const MULTINAME_KIND_NAMES: Map<number, "QName" | "QNameA" | "RTQName" | "RTQNameA" | "RTQNameL" | "RTQNameLA" | "Multiname" | "MultinameA" | "MultinameL" | "MultinameLA" | "TypeName">;
+export declare const TRAIT_KIND_NAMES: Map<number, "Slot" | "Method" | "Getter" | "Setter" | "Class" | "Function" | "Const">;
+export declare const METHOD_FLAG_NAMES: Map<number, "NEED_ARGUMENTS" | "NEED_ACTIVATION" | "NEED_REST" | "HAS_OPTIONAL" | "IGNORE_REST" | "EXPLICIT" | "SET_DXNS" | "HAS_PARAM_NAMES">;
+export declare function isNamespaceKind(kind: number): boolean;

package/dist/abc/constants.js

@@ -0,0 +1,93 @@
+/** Namespace kinds (AVM2 overview §4.4.1). */
+export const NamespaceKind = {
+    Namespace: 0x08,
+    PackageNamespace: 0x16,
+    PackageInternalNs: 0x17,
+    ProtectedNamespace: 0x18,
+    ExplicitNamespace: 0x19,
+    StaticProtectedNs: 0x1a,
+    PrivateNs: 0x05,
+};
+/** Multiname kinds (AVM2 overview §4.4.3). */
+export const MultinameKind = {
+    QName: 0x07,
+    QNameA: 0x0d,
+    RTQName: 0x0f,
+    RTQNameA: 0x10,
+    RTQNameL: 0x11,
+    RTQNameLA: 0x12,
+    Multiname: 0x09,
+    MultinameA: 0x0e,
+    MultinameL: 0x1b,
+    MultinameLA: 0x1c,
+    /** Parameterised type, e.g. Vector.<int>. */
+    TypeName: 0x1d,
+};
+/** Constant value kinds used for optional parameters and slot defaults. */
+export const ConstantKind = {
+    Undefined: 0x00,
+    Utf8: 0x01,
+    Decimal: 0x02,
+    Int: 0x03,
+    UInt: 0x04,
+    PrivateNs: 0x05,
+    Double: 0x06,
+    Namespace: 0x08,
+    False: 0x0a,
+    True: 0x0b,
+    Null: 0x0c,
+    PackageNamespace: 0x16,
+    PackageInternalNs: 0x17,
+    ProtectedNamespace: 0x18,
+    ExplicitNamespace: 0x19,
+    StaticProtectedNs: 0x1a,
+};
+export const MethodFlags = {
+    NEED_ARGUMENTS: 0x01,
+    NEED_ACTIVATION: 0x02,
+    NEED_REST: 0x04,
+    HAS_OPTIONAL: 0x08,
+    IGNORE_REST: 0x10,
+    EXPLICIT: 0x20,
+    SET_DXNS: 0x40,
+    HAS_PARAM_NAMES: 0x80,
+};
+export const InstanceFlags = {
+    Sealed: 0x01,
+    Final: 0x02,
+    Interface: 0x04,
+    ProtectedNs: 0x08,
+};
+export const TraitKind = {
+    Slot: 0,
+    Method: 1,
+    Getter: 2,
+    Setter: 3,
+    Class: 4,
+    Function: 5,
+    Const: 6,
+};
+export const TraitAttr = {
+    Final: 0x1,
+    Override: 0x2,
+    Metadata: 0x4,
+};
+function invert(o) {
+    return new Map(Object.entries(o).map(([k, v]) => [v, k]));
+}
+export const NAMESPACE_KIND_NAMES = new Map([
+    [NamespaceKind.Namespace, 'Namespace'],
+    [NamespaceKind.PackageNamespace, 'PackageNamespace'],
+    [NamespaceKind.PackageInternalNs, 'PackageInternalNs'],
+    [NamespaceKind.ProtectedNamespace, 'ProtectedNamespace'],
+    [NamespaceKind.ExplicitNamespace, 'ExplicitNamespace'],
+    [NamespaceKind.StaticProtectedNs, 'StaticProtectedNs'],
+    [NamespaceKind.PrivateNs, 'PrivateNamespace'],
+]);
+export const NAMESPACE_KIND_BY_NAME = new Map([...NAMESPACE_KIND_NAMES].map(([k, v]) => [v, k]));
+export const MULTINAME_KIND_NAMES = invert(MultinameKind);
+export const TRAIT_KIND_NAMES = invert(TraitKind);
+export const METHOD_FLAG_NAMES = invert(MethodFlags);
+export function isNamespaceKind(kind) {
+    return NAMESPACE_KIND_NAMES.has(kind);
+}

package/dist/abc/interner.d.ts

@@ -0,0 +1,46 @@
+import type { AbcFile, MultinameInfo } from './abc-file.js';
+/**
+ * Content-based constant pool interning.
+ *
+ * Unlike the index-based helpers on {@link AbcFile}, two pool entries are
+ * considered equal when they *mean* the same thing (e.g. a QName whose
+ * namespace refers to a duplicate-but-equal string), so assembling code
+ * reuses existing entries instead of growing the pools. Private namespaces
+ * are identity-based and never merged.
+ */
+export declare class Interner {
+    readonly abc: AbcFile;
+    private strMap;
+    private nsMap;
+    private nsSetMap;
+    private mnMap;
+    private nsKeys;
+    private nsSetKeys;
+    private mnKeys;
+    constructor(abc: AbcFile);
+    private strKey;
+    private registerNs;
+    private registerNsSet;
+    private mnKeyOf;
+    /** Key of an existing multiname; computed on demand because TypeNames may reference later entries. */
+    private mnKeyAt;
+    private registerMn;
+    /** String index; `null` → 0 (no string). */
+    string(s: string | null): number;
+    /**
+     * Namespace index. For private namespaces, `hint` selects an existing
+     * entry; without a hint the only private namespace with that name is used,
+     * or a new one is created if none exists.
+     */
+    namespace(kind: number, name: string | null, hint?: number): number;
+    /** Always creates a new namespace entry (e.g. a fresh private namespace). */
+    addNs(kind: number, nameIndex: number): number;
+    nsSet(namespaces: number[]): number;
+    multiname(partial: Partial<MultinameInfo> & {
+        kind: number;
+    }): number;
+    qname(ns: number, name: string | null): number;
+    int(v: number): number;
+    uint(v: number): number;
+    double(v: number): number;
+}

package/dist/abc/interner.js

@@ -0,0 +1,168 @@
+import { emptyMultiname } from './abc-file.js';
+import { MultinameKind, NamespaceKind } from './constants.js';
+/**
+ * Content-based constant pool interning.
+ *
+ * Unlike the index-based helpers on {@link AbcFile}, two pool entries are
+ * considered equal when they *mean* the same thing (e.g. a QName whose
+ * namespace refers to a duplicate-but-equal string), so assembling code
+ * reuses existing entries instead of growing the pools. Private namespaces
+ * are identity-based and never merged.
+ */
+export class Interner {
+    abc;
+    strMap = new Map();
+    nsMap = new Map();
+    nsSetMap = new Map();
+    mnMap = new Map();
+    nsKeys = [];
+    nsSetKeys = [];
+    mnKeys = [];
+    constructor(abc) {
+        this.abc = abc;
+        abc.strings.forEach((s, i) => {
+            if (i > 0 && !this.strMap.has(s))
+                this.strMap.set(s, i);
+        });
+        abc.namespaces.forEach((_, i) => this.registerNs(i));
+        abc.nsSets.forEach((_, i) => this.registerNsSet(i));
+        abc.multinames.forEach((_, i) => this.registerMn(i));
+    }
+    strKey(i) {
+        return i === 0 ? '∅' : JSON.stringify(this.abc.strings[i] ?? '');
+    }
+    registerNs(i) {
+        const ns = this.abc.namespaces[i];
+        const key = i === 0 ? '*' : ns.kind === NamespaceKind.PrivateNs ? `${ns.kind}:${this.strKey(ns.name)}#${i}` : `${ns.kind}:${this.strKey(ns.name)}`;
+        this.nsKeys[i] = key;
+        if (!this.nsMap.has(key))
+            this.nsMap.set(key, i);
+    }
+    registerNsSet(i) {
+        const key = (this.abc.nsSets[i] ?? []).map((n) => this.nsKeys[n] ?? `?${n}`).join(',');
+        this.nsSetKeys[i] = key;
+        if (i > 0 && !this.nsSetMap.has(key))
+            this.nsSetMap.set(key, i);
+    }
+    mnKeyOf(m) {
+        switch (m.kind) {
+            case MultinameKind.QName:
+            case MultinameKind.QNameA:
+                return `${m.kind}(${this.nsKeys[m.ns]},${this.strKey(m.name)})`;
+            case MultinameKind.RTQName:
+            case MultinameKind.RTQNameA:
+                return `${m.kind}(${this.strKey(m.name)})`;
+            case MultinameKind.RTQNameL:
+            case MultinameKind.RTQNameLA:
+                return `${m.kind}()`;
+            case MultinameKind.Multiname:
+            case MultinameKind.MultinameA:
+                return `${m.kind}(${this.strKey(m.name)},[${this.nsSetKeys[m.nsSet]}])`;
+            case MultinameKind.MultinameL:
+            case MultinameKind.MultinameLA:
+                return `${m.kind}([${this.nsSetKeys[m.nsSet]}])`;
+            case MultinameKind.TypeName:
+                return `${m.kind}(${this.mnKeyAt(m.base)},${m.params.map((p) => this.mnKeyAt(p)).join(',')})`;
+            default:
+                return `?${m.kind}`;
+        }
+    }
+    /** Key of an existing multiname; computed on demand because TypeNames may reference later entries. */
+    mnKeyAt(i, depth = 0) {
+        const cached = this.mnKeys[i];
+        if (cached !== undefined)
+            return cached;
+        const m = this.abc.multinames[i];
+        if (!m || depth > 32)
+            return `?${i}`;
+        if (i === 0)
+            return '*';
+        return this.mnKeyOf(m);
+    }
+    registerMn(i) {
+        const key = i === 0 ? '*' : this.mnKeyOf(this.abc.multinames[i]);
+        this.mnKeys[i] = key;
+        if (!this.mnMap.has(key))
+            this.mnMap.set(key, i);
+    }
+    /** String index; `null` → 0 (no string). */
+    string(s) {
+        if (s === null)
+            return 0;
+        let i = this.strMap.get(s);
+        if (i === undefined) {
+            i = this.abc.strings.length;
+            this.abc.strings.push(s);
+            this.strMap.set(s, i);
+        }
+        return i;
+    }
+    /**
+     * Namespace index. For private namespaces, `hint` selects an existing
+     * entry; without a hint the only private namespace with that name is used,
+     * or a new one is created if none exists.
+     */
+    namespace(kind, name, hint) {
+        const nameIndex = this.string(name);
+        if (kind === NamespaceKind.PrivateNs) {
+            if (hint !== undefined) {
+                const ns = this.abc.namespaces[hint];
+                if (ns && ns.kind === kind && this.strKey(ns.name) === this.strKey(nameIndex))
+                    return hint;
+            }
+            const matches = [];
+            this.abc.namespaces.forEach((ns, i) => {
+                if (i > 0 && ns.kind === kind && this.strKey(ns.name) === this.strKey(nameIndex))
+                    matches.push(i);
+            });
+            if (matches.length === 1)
+                return matches[0];
+            if (matches.length > 1) {
+                throw new Error(`Ambiguous PrivateNamespace(${name === null ? 'null' : JSON.stringify(name)}): candidates ${matches.join(', ')}; add the index, e.g. PrivateNamespace(${JSON.stringify(name)}, ${matches[0]})`);
+            }
+            return this.addNs(kind, nameIndex);
+        }
+        const key = `${kind}:${this.strKey(nameIndex)}`;
+        return this.nsMap.get(key) ?? this.addNs(kind, nameIndex);
+    }
+    /** Always creates a new namespace entry (e.g. a fresh private namespace). */
+    addNs(kind, nameIndex) {
+        const i = this.abc.namespaces.length;
+        this.abc.namespaces.push({ kind, name: nameIndex });
+        this.registerNs(i);
+        return i;
+    }
+    nsSet(namespaces) {
+        const key = namespaces.map((n) => this.nsKeys[n] ?? `?${n}`).join(',');
+        let i = this.nsSetMap.get(key);
+        if (i === undefined) {
+            i = this.abc.nsSets.length;
+            this.abc.nsSets.push([...namespaces]);
+            this.registerNsSet(i);
+        }
+        return i;
+    }
+    multiname(partial) {
+        const m = { ...emptyMultiname(partial.kind), ...partial, params: [...(partial.params ?? [])] };
+        const key = this.mnKeyOf(m);
+        let i = this.mnMap.get(key);
+        if (i === undefined) {
+            i = this.abc.multinames.length;
+            this.abc.multinames.push(m);
+            this.registerMn(i);
+        }
+        return i;
+    }
+    qname(ns, name) {
+        return this.multiname({ kind: MultinameKind.QName, ns, name: this.string(name) });
+    }
+    int(v) {
+        return this.abc.int(v);
+    }
+    uint(v) {
+        return this.abc.uint(v);
+    }
+    double(v) {
+        return this.abc.double(v);
+    }
+}

package/dist/abc/model.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Higher-level navigation over an ABC file: classes, their methods, and
+ * human-readable method descriptions.
+ */
+import type { AbcFile, Trait } from './abc-file.js';
+export type MethodRole = 'script-init' | 'class-init' | 'constructor' | 'method' | 'getter' | 'setter' | 'function' | 'closure';
+export interface MethodRef {
+    methodIndex: number;
+    role: MethodRole;
+    /** Trait / method name ("" for initialisers and anonymous closures). */
+    name: string;
+    isStatic: boolean;
+    trait?: Trait;
+}
+/** Methods created with `newfunction` inside the given methods (recursively). */
+export declare function closuresOf(abc: AbcFile, methodIndices: Iterable<number>): number[];
+/** Script index whose traits define class `classIndex` (-1 if none). */
+export declare function scriptOfClass(abc: AbcFile, classIndex: number): number;
+/**
+ * All methods belonging to a class: static initialiser, constructor, static
+ * and instance methods/accessors and the closures they create.
+ */
+export declare function classMethods(abc: AbcFile, classIndex: number, includeClosures?: boolean): MethodRef[];
+/** Methods of a script: its initialiser plus package-level functions. */
+export declare function scriptMethods(abc: AbcFile, scriptIndex: number, includeClosures?: boolean): MethodRef[];
+export interface FindMethodOptions {
+    /** Restrict to static (true) or instance (false) members. */
+    isStatic?: boolean;
+    role?: MethodRole;
+}
+/**
+ * Finds a method of a class by name. Use the class's own name (or
+ * "constructor") for the constructor and "cinit" for the static initialiser.
+ * Returns the method index or -1.
+ */
+export declare function findMethod(abc: AbcFile, className: string, methodName: string, options?: FindMethodOptions): number;
+/** "com.foo.Bar/doThing", "com.foo.Bar/static get value", "com.foo.Bar/<cinit>", ... */
+export declare function describeMethodRef(abc: AbcFile, owner: string, r: MethodRef): string;
+/** Finds the owner of every method (class or script) and describes it. */
+export declare function methodOwners(abc: AbcFile): Map<number, string>;

package/dist/abc/model.js

@@ -0,0 +1,146 @@
+import { decodeCode } from './code.js';
+import { TraitKind } from './constants.js';
+import { Op } from './opcodes.js';
+const ROLE_BY_TRAIT = {
+    [TraitKind.Method]: 'method',
+    [TraitKind.Getter]: 'getter',
+    [TraitKind.Setter]: 'setter',
+    [TraitKind.Function]: 'function',
+};
+function traitMethods(abc, traits, isStatic) {
+    const out = [];
+    for (const t of traits) {
+        const role = ROLE_BY_TRAIT[t.kind];
+        if (role)
+            out.push({ methodIndex: t.method, role, name: abc.multinameName(t.name), isStatic, trait: t });
+    }
+    return out;
+}
+/** Methods created with `newfunction` inside the given methods (recursively). */
+export function closuresOf(abc, methodIndices) {
+    const seen = new Set(methodIndices);
+    const queue = [...seen];
+    const found = [];
+    while (queue.length) {
+        const m = queue.pop();
+        const body = abc.methodBody(m);
+        if (!body)
+            continue;
+        let items;
+        try {
+            items = decodeCode(body.code, body.exceptions).items;
+        }
+        catch {
+            continue;
+        }
+        for (const it of items) {
+            if (it.type === 'op' && it.op === Op.newfunction) {
+                const f = it.args[0];
+                if (!seen.has(f)) {
+                    seen.add(f);
+                    found.push(f);
+                    queue.push(f);
+                }
+            }
+        }
+    }
+    return found;
+}
+/** Script index whose traits define class `classIndex` (-1 if none). */
+export function scriptOfClass(abc, classIndex) {
+    for (let s = 0; s < abc.scripts.length; s++) {
+        if (abc.scripts[s].traits.some((t) => t.kind === TraitKind.Class && t.classIndex === classIndex))
+            return s;
+    }
+    return -1;
+}
+/**
+ * All methods belonging to a class: static initialiser, constructor, static
+ * and instance methods/accessors and the closures they create.
+ */
+export function classMethods(abc, classIndex, includeClosures = true) {
+    const inst = abc.instances[classIndex];
+    const cls = abc.classes[classIndex];
+    if (!inst || !cls)
+        throw new Error(`Class index ${classIndex} out of range`);
+    const refs = [
+        { methodIndex: cls.cinit, role: 'class-init', name: '', isStatic: true },
+        { methodIndex: inst.iinit, role: 'constructor', name: abc.multinameName(inst.name), isStatic: false },
+        ...traitMethods(abc, cls.traits, true),
+        ...traitMethods(abc, inst.traits, false),
+    ];
+    if (includeClosures) {
+        for (const m of closuresOf(abc, refs.map((r) => r.methodIndex)))
+            refs.push({ methodIndex: m, role: 'closure', name: abc.strings[abc.methods[m]?.name ?? 0] ?? '', isStatic: false });
+    }
+    return refs;
+}
+/** Methods of a script: its initialiser plus package-level functions. */
+export function scriptMethods(abc, scriptIndex, includeClosures = true) {
+    const s = abc.scripts[scriptIndex];
+    if (!s)
+        throw new Error(`Script index ${scriptIndex} out of range`);
+    const refs = [{ methodIndex: s.init, role: 'script-init', name: '', isStatic: true }, ...traitMethods(abc, s.traits, true)];
+    if (includeClosures) {
+        for (const m of closuresOf(abc, refs.map((r) => r.methodIndex)))
+            refs.push({ methodIndex: m, role: 'closure', name: abc.strings[abc.methods[m]?.name ?? 0] ?? '', isStatic: true });
+    }
+    return refs;
+}
+/**
+ * Finds a method of a class by name. Use the class's own name (or
+ * "constructor") for the constructor and "cinit" for the static initialiser.
+ * Returns the method index or -1.
+ */
+export function findMethod(abc, className, methodName, options = {}) {
+    const ci = abc.findClass(className);
+    if (ci < 0)
+        return -1;
+    const refs = classMethods(abc, ci, false);
+    for (const r of refs) {
+        if (options.isStatic !== undefined && r.isStatic !== options.isStatic)
+            continue;
+        if (options.role !== undefined && r.role !== options.role)
+            continue;
+        if (methodName === 'constructor' && r.role === 'constructor')
+            return r.methodIndex;
+        if (methodName === 'cinit' && r.role === 'class-init')
+            return r.methodIndex;
+        if (r.role !== 'class-init' && r.name === methodName)
+            return r.methodIndex;
+    }
+    return -1;
+}
+/** "com.foo.Bar/doThing", "com.foo.Bar/static get value", "com.foo.Bar/<cinit>", ... */
+export function describeMethodRef(abc, owner, r) {
+    switch (r.role) {
+        case 'script-init':
+            return `${owner}/<script init>`;
+        case 'class-init':
+            return `${owner}/<cinit>`;
+        case 'constructor':
+            return `${owner}/<constructor>`;
+        case 'closure':
+            return `${owner}/<closure${r.name ? ' ' + r.name : ''}> (method ${r.methodIndex})`;
+        default: {
+            const prefix = (r.isStatic ? 'static ' : '') + (r.role === 'getter' ? 'get ' : r.role === 'setter' ? 'set ' : r.role === 'function' ? 'function ' : '');
+            return `${owner}/${prefix}${r.name}`;
+        }
+    }
+}
+/** Finds the owner of every method (class or script) and describes it. */
+export function methodOwners(abc) {
+    const map = new Map();
+    for (let c = 0; c < abc.instances.length; c++) {
+        const owner = abc.className(c);
+        for (const r of classMethods(abc, c))
+            if (!map.has(r.methodIndex))
+                map.set(r.methodIndex, describeMethodRef(abc, owner, r));
+    }
+    for (let s = 0; s < abc.scripts.length; s++) {
+        for (const r of scriptMethods(abc, s))
+            if (!map.has(r.methodIndex))
+                map.set(r.methodIndex, describeMethodRef(abc, `script${s}`, r));
+    }
+    return map;
+}

package/dist/abc/opcodes.d.ts

@@ -0,0 +1,39 @@
+/**
+ * AVM2 instruction set table (AVM2 overview, chapter 5).
+ */
+export type OperandType = 
+/** Unsigned byte. */
+'u8'
+/** Signed byte (pushbyte). */
+ | 's8'
+/** Generic u30 immediate (slot index, disp id, line number, ...). */
+ | 'u30'
+/** Signed 32-bit immediate stored as u30 (pushshort). */
+ | 'short'
+/** Argument count (affects stack effect). */
+ | 'argc'
+/** Local register index. */
+ | 'reg' | 'int' | 'uint' | 'double' | 'string' | 'namespace' | 'multiname' | 'method' | 'class' | 'exception'
+/** s24 branch offset, resolved to a label. */
+ | 'branch'
+/** lookupswitch: default + case_count + cases. */
+ | 'switch';
+export type FlowKind = 'jump' | 'cond' | 'switch' | 'return' | 'throw';
+export interface OpInfo {
+    code: number;
+    name: string;
+    operands: OperandType[];
+    /** Fixed number of values popped. */
+    pop: number;
+    /** Extra values popped per argc (0, 1 or 2). */
+    popArgc: number;
+    /** Pops runtime multiname parts (namespace/name) of the multiname operand. */
+    popMn: boolean;
+    push: number;
+    /** Scope stack delta. */
+    scope: number;
+    flow?: FlowKind;
+}
+export declare function opInfo(code: number): OpInfo | undefined;
+export declare function opByName(name: string): OpInfo | undefined;
+export declare const Op: Record<string, number>;