swf-toolkit 0.0.0-stage → 0.1.0

package/dist/abc/pcode/disassembler.js

@@ -0,0 +1,147 @@
+import { decodeCode } from '../code.js';
+import { METHOD_FLAG_NAMES, MethodFlags } from '../constants.js';
+import { opInfo } from '../opcodes.js';
+import { formatDouble, formatMultiname, formatNamespace, formatString, formatTrait, formatValue } from './format.js';
+const labelName = (id) => `L${id}`;
+function hex(data) {
+    return Array.from(data, (b) => b.toString(16).padStart(2, '0')).join(' ');
+}
+/** Formats a single instruction (without indentation). */
+export function formatInstruction(abc, ins) {
+    const info = opInfo(ins.op);
+    if (!info)
+        return `.bytes ${ins.op.toString(16).padStart(2, '0')}`;
+    const parts = [];
+    let a = 0;
+    let comment = '';
+    for (const t of info.operands) {
+        switch (t) {
+            case 'branch':
+                parts.push(labelName(ins.targets[0]));
+                break;
+            case 'switch':
+                parts.push(labelName(ins.targets[0]), `[${ins.targets.slice(1).map(labelName).join(', ')}]`);
+                break;
+            case 'int':
+                parts.push(String(abc.ints[ins.args[a++]] ?? 0));
+                break;
+            case 'uint':
+                parts.push(String(abc.uints[ins.args[a++]] ?? 0));
+                break;
+            case 'double':
+                parts.push(formatDouble(abc.doubles[ins.args[a++]] ?? NaN));
+                break;
+            case 'string':
+                parts.push(formatString(abc, ins.args[a++]));
+                break;
+            case 'namespace':
+                parts.push(formatNamespace(abc, ins.args[a++]));
+                break;
+            case 'multiname':
+                parts.push(formatMultiname(abc, ins.args[a++]));
+                break;
+            case 'class': {
+                const c = ins.args[a++];
+                parts.push(String(c));
+                comment = ` ; ${abc.className(c)}`;
+                break;
+            }
+            default:
+                parts.push(String(ins.args[a++]));
+        }
+    }
+    return parts.length ? `${info.name} ${parts.join(', ')}${comment}` : info.name + comment;
+}
+/** Formats decoded code items, one per line. */
+export function formatCode(abc, code, indent = '  ') {
+    const items = Array.isArray(code) ? code : code.items;
+    const lines = [];
+    for (const it of items) {
+        if (it.type === 'label')
+            lines.push(`${labelName(it.id)}:`);
+        else if (it.type === 'bytes') {
+            for (let i = 0; i < it.data.length; i += 16)
+                lines.push(`${indent}.bytes ${hex(it.data.subarray(i, i + 16))}`);
+        }
+        else
+            lines.push(indent + formatInstruction(abc, it));
+    }
+    return lines;
+}
+function formatFlags(flags) {
+    const names = [];
+    for (const [bit, name] of METHOD_FLAG_NAMES) {
+        if (flags & bit)
+            names.push(name);
+    }
+    const known = [...METHOD_FLAG_NAMES.keys()].reduce((x, y) => x | y, 0);
+    if (flags & ~known & 0xff)
+        names.push(`0x${(flags & ~known & 0xff).toString(16)}`);
+    return names.length ? names.join(' | ') : undefined;
+}
+function bodyLines(abc, body, ind) {
+    const lines = ['body'];
+    let decoded;
+    let error;
+    try {
+        decoded = decodeCode(body.code, body.exceptions);
+    }
+    catch (e) {
+        error = e.message;
+    }
+    lines.push(`${ind}maxstack ${body.maxStack}`);
+    lines.push(`${ind}localcount ${body.localCount}`);
+    lines.push(`${ind}initscopedepth ${body.initScopeDepth}`);
+    lines.push(`${ind}maxscopedepth ${body.maxScopeDepth}`);
+    for (const t of body.traits)
+        lines.push(ind + formatTrait(abc, t));
+    if (!decoded) {
+        // Not representable with labels: emit raw code and numeric exception offsets.
+        lines.push(`${ind}; WARNING: code could not be decoded (${error}); kept as raw bytes`);
+        for (const e of body.exceptions) {
+            lines.push(`${ind}try from @${e.from} to @${e.to} target @${e.target} type ${formatMultiname(abc, e.excType)} name ${formatMultiname(abc, e.varName)}`);
+        }
+        lines.push('code');
+        for (let i = 0; i < body.code.length; i += 16)
+            lines.push(`${ind}.bytes ${hex(body.code.subarray(i, i + 16))}`);
+        return lines;
+    }
+    for (const e of decoded.exceptions) {
+        lines.push(`${ind}try from ${labelName(e.from)} to ${labelName(e.to)} target ${labelName(e.target)} type ${formatMultiname(abc, e.excType)} name ${formatMultiname(abc, e.varName)}`);
+    }
+    lines.push('code');
+    lines.push(...formatCode(abc, decoded, ind));
+    return lines;
+}
+/**
+ * Disassembles a method (signature + body) to P-code text. The output can be
+ * edited and fed back to {@link assembleMethods}.
+ */
+export function disassembleMethod(abc, methodIndex, options = {}) {
+    const ind = options.indent ?? '  ';
+    const m = abc.methods[methodIndex];
+    if (!m)
+        throw new Error(`Method index ${methodIndex} out of range`);
+    const lines = [`method ${methodIndex}${options.title ? ` ; ${options.title}` : ''}`];
+    if (m.name !== 0)
+        lines.push(`${ind}name ${formatString(abc, m.name)}`);
+    lines.push(`${ind}returns ${formatMultiname(abc, m.returnType)}`);
+    for (const p of m.paramTypes)
+        lines.push(`${ind}param ${formatMultiname(abc, p)}`);
+    const flags = formatFlags(m.flags & ~(MethodFlags.HAS_OPTIONAL | MethodFlags.HAS_PARAM_NAMES));
+    if (flags)
+        lines.push(`${ind}flags ${flags}`);
+    if (m.flags & MethodFlags.HAS_OPTIONAL && m.optional.length === 0)
+        lines.push(`${ind}flags HAS_OPTIONAL`);
+    for (const o of m.optional)
+        lines.push(`${ind}optional ${formatValue(abc, o.kind, o.value)}`);
+    for (const p of m.paramNames)
+        lines.push(`${ind}paramname ${formatString(abc, p)}`);
+    if (m.flags & MethodFlags.HAS_PARAM_NAMES && m.paramNames.length === 0)
+        lines.push(`${ind}flags HAS_PARAM_NAMES`);
+    const body = abc.methodBody(methodIndex);
+    if (body)
+        lines.push(...bodyLines(abc, body, ind));
+    lines.push('end');
+    return lines.join('\n') + '\n';
+}

package/dist/abc/pcode/format.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Text formatting of constant pool entries for P-code.
+ *
+ * Syntax (all of it is accepted back by the assembler):
+ *   strings     "text" (JSON escapes), null = string index 0
+ *   namespaces  PackageNamespace("flash.display"), PrivateNamespace("Foo", 12), * = index 0
+ *   multinames  QName(ns, "name"), QNameA(...), RTQName("n"), RTQNameA("n"), RTQNameL(), RTQNameLA(),
+ *               Multiname("n", [ns, ...]), MultinameA(...), MultinameL([ns, ...]), MultinameLA(...),
+ *               TypeName(QName(...), [QName(...), ...]), * = index 0
+ *   values      Integer(1), UInteger(1), Double(1.5), Utf8("s"), True, False, Null, Undefined,
+ *               any namespace syntax
+ */
+import type { AbcFile, Trait } from '../abc-file.js';
+export declare function formatString(abc: AbcFile, index: number): string;
+export declare function formatDouble(v: number): string;
+export declare function formatNamespace(abc: AbcFile, index: number): string;
+export declare function formatNsSet(abc: AbcFile, index: number): string;
+export declare function formatMultiname(abc: AbcFile, index: number): string;
+/** Constant value (optional parameter default / slot initial value). */
+export declare function formatValue(abc: AbcFile, kind: number, index: number): string;
+export declare const TRAIT_KIND_BY_TEXT: Map<string, number>;
+/** One-line trait representation: `trait slot QName(...) slotid 1 type ... value ...`. */
+export declare function formatTrait(abc: AbcFile, t: Trait): string;

package/dist/abc/pcode/format.js

@@ -0,0 +1,131 @@
+import { ConstantKind, MultinameKind, NAMESPACE_KIND_NAMES, NamespaceKind, TraitAttr, TraitKind } from '../constants.js';
+export function formatString(abc, index) {
+    if (index === 0)
+        return 'null';
+    const s = abc.strings[index];
+    return s === undefined ? `null ; invalid string index ${index}` : JSON.stringify(s);
+}
+export function formatDouble(v) {
+    if (Number.isNaN(v))
+        return 'NaN';
+    if (v === Infinity)
+        return 'Infinity';
+    if (v === -Infinity)
+        return '-Infinity';
+    if (Object.is(v, -0))
+        return '-0';
+    return String(v);
+}
+export function formatNamespace(abc, index) {
+    if (index === 0)
+        return '*';
+    const ns = abc.namespaces[index];
+    if (!ns)
+        return `* ; invalid namespace index ${index}`;
+    const kind = NAMESPACE_KIND_NAMES.get(ns.kind) ?? `Namespace_0x${ns.kind.toString(16)}`;
+    const name = formatString(abc, ns.name);
+    if (ns.kind === NamespaceKind.PrivateNs)
+        return `${kind}(${name}, ${index})`;
+    return `${kind}(${name})`;
+}
+export function formatNsSet(abc, index) {
+    const set = abc.nsSets[index] ?? [];
+    return `[${set.map((n) => formatNamespace(abc, n)).join(', ')}]`;
+}
+export function formatMultiname(abc, index) {
+    if (index === 0)
+        return '*';
+    const m = abc.multinames[index];
+    if (!m)
+        return `* ; invalid multiname index ${index}`;
+    const K = MultinameKind;
+    switch (m.kind) {
+        case K.QName:
+            return `QName(${formatNamespace(abc, m.ns)}, ${formatString(abc, m.name)})`;
+        case K.QNameA:
+            return `QNameA(${formatNamespace(abc, m.ns)}, ${formatString(abc, m.name)})`;
+        case K.RTQName:
+            return `RTQName(${formatString(abc, m.name)})`;
+        case K.RTQNameA:
+            return `RTQNameA(${formatString(abc, m.name)})`;
+        case K.RTQNameL:
+            return 'RTQNameL()';
+        case K.RTQNameLA:
+            return 'RTQNameLA()';
+        case K.Multiname:
+            return `Multiname(${formatString(abc, m.name)}, ${formatNsSet(abc, m.nsSet)})`;
+        case K.MultinameA:
+            return `MultinameA(${formatString(abc, m.name)}, ${formatNsSet(abc, m.nsSet)})`;
+        case K.MultinameL:
+            return `MultinameL(${formatNsSet(abc, m.nsSet)})`;
+        case K.MultinameLA:
+            return `MultinameLA(${formatNsSet(abc, m.nsSet)})`;
+        case K.TypeName:
+            return `TypeName(${formatMultiname(abc, m.base)}, [${m.params.map((p) => formatMultiname(abc, p)).join(', ')}])`;
+        default:
+            return `* ; unknown multiname kind 0x${m.kind.toString(16)}`;
+    }
+}
+/** Constant value (optional parameter default / slot initial value). */
+export function formatValue(abc, kind, index) {
+    const C = ConstantKind;
+    switch (kind) {
+        case C.Int:
+            return `Integer(${abc.ints[index] ?? 0})`;
+        case C.UInt:
+            return `UInteger(${abc.uints[index] ?? 0})`;
+        case C.Double:
+            return `Double(${formatDouble(abc.doubles[index] ?? NaN)})`;
+        case C.Utf8:
+            return `Utf8(${formatString(abc, index)})`;
+        case C.True:
+        case C.False:
+        case C.Null:
+        case C.Undefined: {
+            // Compilers store the kind itself as the (unused) index; keep any other value explicit.
+            const name = kind === C.True ? 'True' : kind === C.False ? 'False' : kind === C.Null ? 'Null' : 'Undefined';
+            return index === kind ? name : `${name}(${index})`;
+        }
+        default:
+            if (NAMESPACE_KIND_NAMES.has(kind))
+                return formatNamespace(abc, index);
+            return `RawValue(${kind}, ${index})`;
+    }
+}
+const TRAIT_KIND_TEXT = {
+    [TraitKind.Slot]: 'slot',
+    [TraitKind.Const]: 'const',
+    [TraitKind.Method]: 'method',
+    [TraitKind.Getter]: 'getter',
+    [TraitKind.Setter]: 'setter',
+    [TraitKind.Class]: 'class',
+    [TraitKind.Function]: 'function',
+};
+export const TRAIT_KIND_BY_TEXT = new Map(Object.entries(TRAIT_KIND_TEXT).map(([k, v]) => [v, Number(k)]));
+/** One-line trait representation: `trait slot QName(...) slotid 1 type ... value ...`. */
+export function formatTrait(abc, t) {
+    const parts = [`trait ${TRAIT_KIND_TEXT[t.kind] ?? `kind${t.kind}`} ${formatMultiname(abc, t.name)}`];
+    switch (t.kind) {
+        case TraitKind.Slot:
+        case TraitKind.Const:
+            parts.push(`slotid ${t.id}`, `type ${formatMultiname(abc, t.typeName)}`);
+            if (t.valueIndex !== 0 || t.valueKind !== 0)
+                parts.push(`value ${formatValue(abc, t.valueKind, t.valueIndex)}`);
+            break;
+        case TraitKind.Class:
+            parts.push(`slotid ${t.id}`, `class ${t.classIndex}`);
+            break;
+        case TraitKind.Function:
+            parts.push(`slotid ${t.id}`, `method ${t.method}`);
+            break;
+        default:
+            parts.push(`dispid ${t.id}`, `method ${t.method}`);
+    }
+    if (t.attrs & TraitAttr.Final)
+        parts.push('final');
+    if (t.attrs & TraitAttr.Override)
+        parts.push('override');
+    if (t.attrs & TraitAttr.Metadata)
+        parts.push(`metadata [${t.metadata.join(', ')}]`);
+    return parts.join(' ');
+}

package/dist/abc/pcode/lexer.d.ts

@@ -0,0 +1,34 @@
+import { AssemblerError } from '../../errors.js';
+export type TokenType = 'id' | 'num' | 'str' | 'punct' | 'offset';
+export interface Token {
+    type: TokenType;
+    /** Identifier text, punctuation char, or original number text. */
+    text: string;
+    /** Parsed value for numbers / strings / offsets. */
+    value?: number | string;
+    col: number;
+}
+/** Tokenises one line of P-code. `;` starts a comment outside of strings. */
+export declare function tokenizeLine(line: string, lineNo: number, source?: string): Token[];
+/** Cursor over the tokens of one line. */
+export declare class LineCursor {
+    readonly tokens: Token[];
+    readonly line: number;
+    readonly source?: string | undefined;
+    pos: number;
+    constructor(tokens: Token[], line: number, source?: string | undefined);
+    get done(): boolean;
+    peek(offset?: number): Token | undefined;
+    error(message: string, tok?: Token | undefined): AssemblerError;
+    next(): Token;
+    isPunct(p: string): boolean;
+    isId(text?: string): boolean;
+    punct(p: string): void;
+    tryPunct(p: string): boolean;
+    id(expected?: string): string;
+    number(): number;
+    integer(min?: number, max?: number): number;
+    /** String literal or `null`. */
+    stringOrNull(): string | null;
+    end(): void;
+}

package/dist/abc/pcode/lexer.js

@@ -0,0 +1,183 @@
+import { AssemblerError } from '../../errors.js';
+const PUNCT = new Set(['(', ')', '[', ']', ',', ':', '|', '*']);
+const ID_START = /[A-Za-z_$]/;
+const ID_PART = /[A-Za-z0-9_$.]/;
+const NUM_RE = /^-?(?:0x[0-9a-fA-F]+|(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)/;
+/** Tokenises one line of P-code. `;` starts a comment outside of strings. */
+export function tokenizeLine(line, lineNo, source) {
+    const tokens = [];
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith('.bytes')) {
+        // Raw byte directive: `.bytes 0a ff 3c ; comment`
+        const indent = line.length - trimmed.length;
+        tokens.push({ type: 'id', text: '.bytes', col: indent + 1 });
+        const re = /[^\s;]+|;/g;
+        let m;
+        re.lastIndex = indent + 6;
+        while ((m = re.exec(line))) {
+            if (m[0] === ';')
+                break;
+            tokens.push({ type: 'id', text: m[0], col: m.index + 1 });
+        }
+        return tokens;
+    }
+    let i = 0;
+    const n = line.length;
+    while (i < n) {
+        const c = line[i];
+        if (c === ' ' || c === '\t' || c === '\r') {
+            i++;
+            continue;
+        }
+        if (c === ';')
+            break;
+        const col = i + 1;
+        if (c === '"') {
+            let j = i + 1;
+            while (j < n && line[j] !== '"')
+                j += line[j] === '\\' ? 2 : 1;
+            if (j >= n)
+                throw new AssemblerError('Unterminated string', lineNo, col, source);
+            const text = line.slice(i, j + 1);
+            let value;
+            try {
+                value = JSON.parse(text);
+            }
+            catch {
+                throw new AssemblerError(`Invalid string literal ${text}`, lineNo, col, source);
+            }
+            tokens.push({ type: 'str', text, value, col });
+            i = j + 1;
+            continue;
+        }
+        if (c === '@') {
+            const m = /^@(\d+)/.exec(line.slice(i));
+            if (!m)
+                throw new AssemblerError('Expected byte offset after @', lineNo, col, source);
+            tokens.push({ type: 'offset', text: m[0], value: Number(m[1]), col });
+            i += m[0].length;
+            continue;
+        }
+        const rest = line.slice(i);
+        if (/[-0-9.]/.test(c)) {
+            if (rest.startsWith('-Infinity')) {
+                tokens.push({ type: 'num', text: '-Infinity', value: -Infinity, col });
+                i += 9;
+                continue;
+            }
+            const m = NUM_RE.exec(rest);
+            if (m) {
+                const text = m[0];
+                const neg = text.startsWith('-');
+                const body = neg ? text.slice(1) : text;
+                let value = body.startsWith('0x') ? parseInt(body.slice(2), 16) : Number(body);
+                if (neg)
+                    value = -value;
+                tokens.push({ type: 'num', text, value, col });
+                i += text.length;
+                continue;
+            }
+        }
+        if (ID_START.test(c)) {
+            let j = i + 1;
+            while (j < n && ID_PART.test(line[j]))
+                j++;
+            const text = line.slice(i, j);
+            if (text === 'NaN' || text === 'Infinity')
+                tokens.push({ type: 'num', text, value: text === 'NaN' ? NaN : Infinity, col });
+            else
+                tokens.push({ type: 'id', text, col });
+            i = j;
+            continue;
+        }
+        if (PUNCT.has(c)) {
+            tokens.push({ type: 'punct', text: c, col });
+            i++;
+            continue;
+        }
+        throw new AssemblerError(`Unexpected character '${c}'`, lineNo, col, source);
+    }
+    return tokens;
+}
+/** Cursor over the tokens of one line. */
+export class LineCursor {
+    tokens;
+    line;
+    source;
+    pos = 0;
+    constructor(tokens, line, source) {
+        this.tokens = tokens;
+        this.line = line;
+        this.source = source;
+    }
+    get done() {
+        return this.pos >= this.tokens.length;
+    }
+    peek(offset = 0) {
+        return this.tokens[this.pos + offset];
+    }
+    error(message, tok = this.peek()) {
+        const col = tok?.col ?? (this.tokens.length ? this.tokens[this.tokens.length - 1].col + this.tokens[this.tokens.length - 1].text.length : 1);
+        return new AssemblerError(message, this.line, col, this.source);
+    }
+    next() {
+        const t = this.tokens[this.pos];
+        if (!t)
+            throw this.error('Unexpected end of line');
+        this.pos++;
+        return t;
+    }
+    isPunct(p) {
+        const t = this.peek();
+        return t?.type === 'punct' && t.text === p;
+    }
+    isId(text) {
+        const t = this.peek();
+        return t?.type === 'id' && (text === undefined || t.text === text);
+    }
+    punct(p) {
+        const t = this.next();
+        if (t.type !== 'punct' || t.text !== p)
+            throw this.error(`Expected '${p}'`, t);
+    }
+    tryPunct(p) {
+        if (this.isPunct(p)) {
+            this.pos++;
+            return true;
+        }
+        return false;
+    }
+    id(expected) {
+        const t = this.next();
+        if (t.type !== 'id' || (expected !== undefined && t.text !== expected)) {
+            throw this.error(expected ? `Expected '${expected}'` : 'Expected identifier', t);
+        }
+        return t.text;
+    }
+    number() {
+        const t = this.next();
+        if (t.type !== 'num')
+            throw this.error('Expected number', t);
+        return t.value;
+    }
+    integer(min = -Infinity, max = Infinity) {
+        const tok = this.peek();
+        const v = this.number();
+        if (!Number.isInteger(v) || v < min || v > max)
+            throw this.error(`Expected integer in range ${min}..${max}`, tok);
+        return v;
+    }
+    /** String literal or `null`. */
+    stringOrNull() {
+        const t = this.next();
+        if (t.type === 'str')
+            return t.value;
+        if (t.type === 'id' && t.text === 'null')
+            return null;
+        throw this.error('Expected string or null', t);
+    }
+    end() {
+        if (!this.done)
+            throw this.error(`Unexpected '${this.peek().text}'`);
+    }
+}

package/dist/assets/assets.d.ts

@@ -0,0 +1,26 @@
+import type { Swf } from '../swf/swf.js';
+import { RawTag, type Tag } from '../swf/tags.js';
+export type AssetKind = 'images' | 'sounds' | 'binary' | 'texts';
+export declare const ALL_ASSET_KINDS: AssetKind[];
+export interface ExportAssetsResult {
+    files: string[];
+    /** Characters that could not be exported, with the reason. */
+    skipped: Array<{
+        id: number;
+        reason: string;
+    }>;
+}
+/** Class / export names per character id (SymbolClass + ExportAssets). */
+export declare function symbolNames(swf: Swf): Map<number, string[]>;
+/** Initial text of a DefineEditText tag (undefined when it has none). */
+export declare function editTextOf(tag: RawTag): {
+    text: string;
+    offset: number;
+    end: number;
+} | undefined;
+/** Writes resources into `outDir/<kind>/<id>[_<symbol>].<ext>`. */
+export declare function exportAssets(swf: Swf, outDir: string, kinds?: AssetKind[]): Promise<ExportAssetsResult>;
+/** Replaces a DefineEditText's initial text. */
+export declare function replaceEditText(swf: Swf, id: number, text: string): Tag;
+/** Replaces the resource with character `id` using a file's contents (type chosen by the tag). */
+export declare function replaceAsset(swf: Swf, id: number, file: Uint8Array): Tag;