swf-toolkit 0.0.0-stage → 0.1.0

package/dist/cjs/avm1/project.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionBlocks = actionBlocks;
+exports.disassembleBlock = disassembleBlock;
+exports.assembleBlock = assembleBlock;
+exports.exportAs2 = exportAs2;
+exports.importAs2 = importAs2;
+/**
+ * AS1/AS2 code blocks (DoAction / DoInitAction) export & import as P-code.
+ */
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const tag_codes_js_1 = require("../swf/tag-codes.js");
+const tags_js_1 = require("../swf/tags.js");
+const avm1_js_1 = require("./avm1.js");
+/** All AVM1 code blocks of an SWF (main timeline and sprites). */
+function actionBlocks(swf) {
+    const out = [];
+    const frames = new Map();
+    for (const { tag, parent, index } of swf.walkTags()) {
+        const owner = parent ?? swf;
+        if (tag.code === tag_codes_js_1.TagCode.ShowFrame)
+            frames.set(owner, (frames.get(owner) ?? 0) + 1);
+        if (!(tag instanceof tags_js_1.RawTag) || (tag.code !== tag_codes_js_1.TagCode.DoAction && tag.code !== tag_codes_js_1.TagCode.DoInitAction))
+            continue;
+        const scope = parent ? `sprite${parent.spriteId}` : 'root';
+        const init = tag.code === tag_codes_js_1.TagCode.DoInitAction;
+        const key = `${scope}_f${frames.get(owner) ?? 0}_t${index}${init ? `_init${tag.data[0] | (tag.data[1] << 8)}` : ''}`;
+        out.push({ key, tag, offset: init ? 2 : 0 });
+    }
+    return out;
+}
+function disassembleBlock(b) {
+    return (0, avm1_js_1.formatActions)((0, avm1_js_1.decodeActions)(b.tag.data.subarray(b.offset)));
+}
+function assembleBlock(b, text) {
+    const code = (0, avm1_js_1.encodeActions)((0, avm1_js_1.parseActions)(text));
+    const data = new Uint8Array(b.offset + code.length);
+    data.set(b.tag.data.subarray(0, b.offset), 0);
+    data.set(code, b.offset);
+    b.tag.data = data;
+}
+async function exportAs2(swf, dir) {
+    await (0, promises_1.mkdir)(dir, { recursive: true });
+    const files = [];
+    for (const b of actionBlocks(swf)) {
+        let text;
+        try {
+            text = disassembleBlock(b);
+        }
+        catch (e) {
+            text = `; could not decode: ${e.message}\n`;
+        }
+        const p = (0, node_path_1.join)(dir, `${b.key}.as2pcode`);
+        await (0, promises_1.writeFile)(p, text, 'utf8');
+        files.push(p);
+    }
+    return files;
+}
+/** Re-assembles blocks whose files changed. Returns the keys that were updated. */
+async function importAs2(swf, dir) {
+    const present = new Set(await (0, promises_1.readdir)(dir));
+    const changed = [];
+    for (const b of actionBlocks(swf)) {
+        const name = `${b.key}.as2pcode`;
+        if (!present.has(name))
+            continue;
+        const text = await (0, promises_1.readFile)((0, node_path_1.join)(dir, name), 'utf8');
+        let current;
+        try {
+            current = disassembleBlock(b);
+        }
+        catch {
+            current = '';
+        }
+        const norm = (s) => s.split('\n').map((l) => l.replace(/;.*$/, '').trim()).filter(Boolean).join('\n');
+        if (norm(text) === norm(current))
+            continue;
+        try {
+            assembleBlock(b, text);
+        }
+        catch (e) {
+            throw new Error(`${name}: ${e.message}`);
+        }
+        changed.push(b.key);
+    }
+    return changed;
+}

package/dist/cjs/compiler/ast.d.ts

@@ -0,0 +1,285 @@
+/** AST produced by the AS3 parser. */
+export interface Pos {
+    line: number;
+    col: number;
+}
+export interface TypeRef {
+    name: string;
+    /** Vector.<T> parameters. */
+    params?: TypeRef[];
+    pos: Pos;
+}
+export type Expr = ({
+    k: 'num';
+    v: number;
+} | {
+    k: 'str';
+    v: string;
+} | {
+    k: 'bool';
+    v: boolean;
+} | {
+    k: 'null';
+} | {
+    k: 'undefined';
+} | {
+    k: 'regex';
+    pattern: string;
+    flags: string;
+} | {
+    k: 'id';
+    name: string;
+    ns?: string;
+} | {
+    k: 'this';
+} | {
+    k: 'super';
+} | {
+    k: 'member';
+    obj: Expr;
+    name: string;
+    ns?: string;
+    attr?: boolean;
+} | {
+    k: 'index';
+    obj: Expr;
+    index: Expr;
+    attr?: boolean;
+} | {
+    k: 'descendants';
+    obj: Expr;
+    name: string;
+    attr?: boolean;
+} | {
+    k: 'filter';
+    obj: Expr;
+    cond: Expr;
+} | {
+    k: 'typeapply';
+    base: Expr;
+    params: TypeRef[];
+} | {
+    k: 'call';
+    fn: Expr;
+    args: Expr[];
+} | {
+    k: 'new';
+    ctor: Expr;
+    args: Expr[];
+} | {
+    k: 'vector';
+    type: TypeRef;
+    items: Expr[];
+} | {
+    k: 'unary';
+    op: string;
+    e: Expr;
+} | {
+    k: 'update';
+    op: '++' | '--';
+    prefix: boolean;
+    e: Expr;
+} | {
+    k: 'binary';
+    op: string;
+    a: Expr;
+    b: Expr;
+} | {
+    k: 'cond';
+    c: Expr;
+    t: Expr;
+    f: Expr;
+} | {
+    k: 'assign';
+    op: string;
+    target: Expr;
+    v: Expr;
+} | {
+    k: 'array';
+    items: Array<Expr | null>;
+} | {
+    k: 'object';
+    props: Array<{
+        key: string | number;
+        value: Expr;
+    }>;
+} | {
+    k: 'function';
+    fn: FunctionDef;
+} | {
+    k: 'comma';
+    list: Expr[];
+} | {
+    k: 'xml';
+    text: string;
+}) & {
+    pos: Pos;
+};
+export interface Param {
+    name: string;
+    type?: TypeRef;
+    init?: Expr;
+}
+export interface FunctionDef {
+    name?: string;
+    params: Param[];
+    rest?: {
+        name: string;
+        type?: TypeRef;
+    };
+    returnType?: TypeRef;
+    body?: Stmt[];
+    pos: Pos;
+}
+export interface VarDecl {
+    name: string;
+    type?: TypeRef;
+    init?: Expr;
+    pos: Pos;
+}
+export interface CatchClause {
+    name: string;
+    type?: TypeRef;
+    body: Stmt[];
+}
+export type Stmt = ({
+    k: 'expr';
+    e: Expr;
+} | {
+    k: 'var';
+    isConst: boolean;
+    decls: VarDecl[];
+} | {
+    k: 'function';
+    fn: FunctionDef;
+} | {
+    k: 'if';
+    c: Expr;
+    then: Stmt;
+    else?: Stmt;
+} | {
+    k: 'while';
+    c: Expr;
+    body: Stmt;
+} | {
+    k: 'dowhile';
+    c: Expr;
+    body: Stmt;
+} | {
+    k: 'for';
+    init?: Stmt;
+    c?: Expr;
+    update?: Expr;
+    body: Stmt;
+} | {
+    k: 'forin';
+    each: boolean;
+    decl?: VarDecl;
+    target?: Expr;
+    obj: Expr;
+    body: Stmt;
+} | {
+    k: 'switch';
+    disc: Expr;
+    cases: Array<{
+        test: Expr | null;
+        body: Stmt[];
+    }>;
+} | {
+    k: 'try';
+    body: Stmt[];
+    catches: CatchClause[];
+    finally?: Stmt[];
+} | {
+    k: 'return';
+    e?: Expr;
+} | {
+    k: 'throw';
+    e: Expr;
+} | {
+    k: 'break';
+    label?: string;
+} | {
+    k: 'continue';
+    label?: string;
+} | {
+    k: 'block';
+    body: Stmt[];
+} | {
+    k: 'labeled';
+    label: string;
+    body: Stmt;
+} | {
+    k: 'with';
+    obj: Expr;
+    body: Stmt;
+} | {
+    k: 'dxns';
+    e: Expr;
+} | {
+    k: 'empty';
+}) & {
+    pos: Pos;
+};
+export interface Metadata {
+    name: string;
+    items: Array<{
+        key?: string;
+        value: string;
+    }>;
+}
+export interface FieldMember {
+    k: 'field';
+    name: string;
+    isStatic: boolean;
+    isConst: boolean;
+    access: string;
+    type?: TypeRef;
+    init?: Expr;
+    metadata: Metadata[];
+    pos: Pos;
+    /** Source span [start, end) of the declaration. */
+    span: [number, number];
+}
+export interface MethodMember {
+    k: 'method';
+    name: string;
+    kind: 'method' | 'get' | 'set' | 'constructor';
+    isStatic: boolean;
+    isOverride: boolean;
+    isFinal: boolean;
+    isNative: boolean;
+    access: string;
+    fn: FunctionDef;
+    metadata: Metadata[];
+    pos: Pos;
+    span: [number, number];
+}
+export interface StaticBlockMember {
+    k: 'static';
+    body: Stmt[];
+    pos: Pos;
+    span: [number, number];
+}
+export type Member = FieldMember | MethodMember | StaticBlockMember;
+export interface ClassDef {
+    name: string;
+    isInterface: boolean;
+    isDynamic: boolean;
+    isFinal: boolean;
+    access: string;
+    extends?: TypeRef;
+    implements: TypeRef[];
+    members: Member[];
+    metadata: Metadata[];
+    pos: Pos;
+}
+export interface CompilationUnit {
+    package: string;
+    imports: string[];
+    /** `use namespace x` declarations. */
+    useNamespaces: string[];
+    classes: ClassDef[];
+    /** Package-level functions / variables (rare). */
+    functions: MethodMember[];
+}

package/dist/cjs/compiler/ast.js

@@ -0,0 +1,3 @@
+"use strict";
+/** AST produced by the AS3 parser. */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/compiler/class-compiler.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Compiles an edited AS3 class back into an existing ABC.
+ *
+ * Only members whose source text changed compared with a baseline (by
+ * default the decompiled text of the current bytecode) are recompiled; all
+ * other methods keep their original bytecode.
+ */
+import type { AbcFile } from '../abc/abc-file.js';
+import { Interner } from '../abc/interner.js';
+export interface CompileClassOptions {
+    /** File name used in error messages. */
+    source?: string;
+    /**
+     * Baseline source the edit started from. Members identical to the baseline
+     * are not recompiled. Defaults to the decompiled class; pass `null` to
+     * recompile every member.
+     */
+    baseline?: string | null;
+    /** Reuse an interner across calls on the same ABC. */
+    interner?: Interner;
+    /** Exact class index to compile into (for ABCs with duplicate class names). */
+    classIndex?: number;
+}
+export interface CompiledMember {
+    className: string;
+    member: string;
+    action: 'replaced' | 'added';
+    methodIndex?: number;
+}
+export interface CompileClassResult {
+    changes: CompiledMember[];
+}
+/** Compiles every class in `source` into `abc`. */
+export declare function compileClassSource(abc: AbcFile, source: string, options?: CompileClassOptions): CompileClassResult;