swf-toolkit 0.0.0-stage → 0.1.0

package/dist/cjs/errors.d.ts

@@ -0,0 +1,11 @@
+/** Thrown when SWF / ABC binary data is malformed or truncated. */
+export declare class SwfFormatError extends Error {
+    constructor(message: string);
+}
+/** Thrown by the P-code assembler, with source position information. */
+export declare class AssemblerError extends Error {
+    readonly line: number;
+    readonly column: number;
+    readonly source?: string;
+    constructor(message: string, line: number, column: number, source?: string);
+}

package/dist/cjs/errors.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssemblerError = exports.SwfFormatError = void 0;
+/** Thrown when SWF / ABC binary data is malformed or truncated. */
+class SwfFormatError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SwfFormatError';
+    }
+}
+exports.SwfFormatError = SwfFormatError;
+/** Thrown by the P-code assembler, with source position information. */
+class AssemblerError extends Error {
+    line;
+    column;
+    source;
+    constructor(message, line, column, source) {
+        super(`${source ? source + ':' : ''}${line}:${column}: ${message}`);
+        this.name = 'AssemblerError';
+        this.line = line;
+        this.column = column;
+        this.source = source;
+    }
+}
+exports.AssemblerError = AssemblerError;

package/dist/cjs/index.d.ts

@@ -0,0 +1,41 @@
+export * from './errors.js';
+export { ByteReader } from './io/reader.js';
+export { ByteWriter } from './io/writer.js';
+export * from './compression/lzma.js';
+export * from './compression/swf-container.js';
+export * from './swf/tag-codes.js';
+export * from './swf/tags.js';
+export * from './swf/swf.js';
+export * from './abc/constants.js';
+export * from './abc/abc-file.js';
+export * from './abc/opcodes.js';
+export * from './abc/code.js';
+export * from './abc/analysis.js';
+export * from './abc/interner.js';
+export * from './abc/model.js';
+export * from './abc/pcode/format.js';
+export * from './abc/pcode/disassembler.js';
+export * from './abc/pcode/assembler.js';
+export { tokenizeLine } from './abc/pcode/lexer.js';
+export * from './project/pcode-project.js';
+export * from './decompiler/ast.js';
+export { buildCfg, findLoops, dominates, type Cfg, type Block, type Loop } from './decompiler/cfg.js';
+export { simulate, SimulationError, type MethodContext, type Terminator } from './decompiler/simulate.js';
+export { Structurer } from './decompiler/structure.js';
+export * from './decompiler/method.js';
+export * from './decompiler/class-printer.js';
+export * from './project/source-export.js';
+export { CompileError, tokenize as tokenizeAs3 } from './compiler/lexer.js';
+export type * as As3Ast from './compiler/ast.js';
+export { parseAs3, Parser as As3Parser } from './compiler/parser.js';
+export { FunctionCompiler, TOPLEVEL_NAMES, type ClassScope, type FunctionOptions } from './compiler/codegen.js';
+export { buildClassScope } from './compiler/scope.js';
+export * from './compiler/class-compiler.js';
+export * from './compiler/program.js';
+export * from './project/source-import.js';
+export * from './assets/png.js';
+export * from './assets/images.js';
+export * from './assets/sounds.js';
+export * from './assets/assets.js';
+export * from './avm1/avm1.js';
+export * from './avm1/project.js';

package/dist/cjs/index.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildClassScope = exports.TOPLEVEL_NAMES = exports.FunctionCompiler = exports.As3Parser = exports.parseAs3 = exports.tokenizeAs3 = exports.CompileError = exports.Structurer = exports.SimulationError = exports.simulate = exports.dominates = exports.findLoops = exports.buildCfg = exports.tokenizeLine = exports.ByteWriter = exports.ByteReader = void 0;
+__exportStar(require("./errors.js"), exports);
+var reader_js_1 = require("./io/reader.js");
+Object.defineProperty(exports, "ByteReader", { enumerable: true, get: function () { return reader_js_1.ByteReader; } });
+var writer_js_1 = require("./io/writer.js");
+Object.defineProperty(exports, "ByteWriter", { enumerable: true, get: function () { return writer_js_1.ByteWriter; } });
+// Compression
+__exportStar(require("./compression/lzma.js"), exports);
+__exportStar(require("./compression/swf-container.js"), exports);
+// SWF container and tags
+__exportStar(require("./swf/tag-codes.js"), exports);
+__exportStar(require("./swf/tags.js"), exports);
+__exportStar(require("./swf/swf.js"), exports);
+// AVM2 / ABC
+__exportStar(require("./abc/constants.js"), exports);
+__exportStar(require("./abc/abc-file.js"), exports);
+__exportStar(require("./abc/opcodes.js"), exports);
+__exportStar(require("./abc/code.js"), exports);
+__exportStar(require("./abc/analysis.js"), exports);
+__exportStar(require("./abc/interner.js"), exports);
+__exportStar(require("./abc/model.js"), exports);
+// P-code
+__exportStar(require("./abc/pcode/format.js"), exports);
+__exportStar(require("./abc/pcode/disassembler.js"), exports);
+__exportStar(require("./abc/pcode/assembler.js"), exports);
+var lexer_js_1 = require("./abc/pcode/lexer.js");
+Object.defineProperty(exports, "tokenizeLine", { enumerable: true, get: function () { return lexer_js_1.tokenizeLine; } });
+// Project-level workflows
+__exportStar(require("./project/pcode-project.js"), exports);
+// Decompiler
+__exportStar(require("./decompiler/ast.js"), exports);
+var cfg_js_1 = require("./decompiler/cfg.js");
+Object.defineProperty(exports, "buildCfg", { enumerable: true, get: function () { return cfg_js_1.buildCfg; } });
+Object.defineProperty(exports, "findLoops", { enumerable: true, get: function () { return cfg_js_1.findLoops; } });
+Object.defineProperty(exports, "dominates", { enumerable: true, get: function () { return cfg_js_1.dominates; } });
+var simulate_js_1 = require("./decompiler/simulate.js");
+Object.defineProperty(exports, "simulate", { enumerable: true, get: function () { return simulate_js_1.simulate; } });
+Object.defineProperty(exports, "SimulationError", { enumerable: true, get: function () { return simulate_js_1.SimulationError; } });
+var structure_js_1 = require("./decompiler/structure.js");
+Object.defineProperty(exports, "Structurer", { enumerable: true, get: function () { return structure_js_1.Structurer; } });
+__exportStar(require("./decompiler/method.js"), exports);
+__exportStar(require("./decompiler/class-printer.js"), exports);
+__exportStar(require("./project/source-export.js"), exports);
+// Compiler
+var lexer_js_2 = require("./compiler/lexer.js");
+Object.defineProperty(exports, "CompileError", { enumerable: true, get: function () { return lexer_js_2.CompileError; } });
+Object.defineProperty(exports, "tokenizeAs3", { enumerable: true, get: function () { return lexer_js_2.tokenize; } });
+var parser_js_1 = require("./compiler/parser.js");
+Object.defineProperty(exports, "parseAs3", { enumerable: true, get: function () { return parser_js_1.parseAs3; } });
+Object.defineProperty(exports, "As3Parser", { enumerable: true, get: function () { return parser_js_1.Parser; } });
+var codegen_js_1 = require("./compiler/codegen.js");
+Object.defineProperty(exports, "FunctionCompiler", { enumerable: true, get: function () { return codegen_js_1.FunctionCompiler; } });
+Object.defineProperty(exports, "TOPLEVEL_NAMES", { enumerable: true, get: function () { return codegen_js_1.TOPLEVEL_NAMES; } });
+var scope_js_1 = require("./compiler/scope.js");
+Object.defineProperty(exports, "buildClassScope", { enumerable: true, get: function () { return scope_js_1.buildClassScope; } });
+__exportStar(require("./compiler/class-compiler.js"), exports);
+__exportStar(require("./compiler/program.js"), exports);
+__exportStar(require("./project/source-import.js"), exports);
+// Assets
+__exportStar(require("./assets/png.js"), exports);
+__exportStar(require("./assets/images.js"), exports);
+__exportStar(require("./assets/sounds.js"), exports);
+__exportStar(require("./assets/assets.js"), exports);
+// AVM1 (AS1/AS2)
+__exportStar(require("./avm1/avm1.js"), exports);
+__exportStar(require("./avm1/project.js"), exports);

package/dist/cjs/io/reader.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Little-endian binary reader with SWF bit-field support.
+ *
+ * Bit reads (`ub`, `sb`, `fb`) share an internal bit buffer; any byte-aligned
+ * read implicitly re-aligns to the next byte boundary, as required by the SWF
+ * specification.
+ */
+export declare class ByteReader {
+    readonly bytes: Uint8Array;
+    readonly view: DataView;
+    pos: number;
+    readonly end: number;
+    private bitBuf;
+    private bitCount;
+    constructor(bytes: Uint8Array, start?: number, end?: number);
+    get remaining(): number;
+    get eof(): boolean;
+    private need;
+    align(): void;
+    u8(): number;
+    s8(): number;
+    u16(): number;
+    s16(): number;
+    u24(): number;
+    s24(): number;
+    u32(): number;
+    s32(): number;
+    f32(): number;
+    f64(): number;
+    /** 8.8 fixed point. */
+    fixed8(): number;
+    /** 16.16 fixed point. */
+    fixed(): number;
+    bytesView(n: number): Uint8Array;
+    /** Copy of the next `n` bytes. */
+    bytesCopy(n: number): Uint8Array;
+    rest(): Uint8Array;
+    /** Null-terminated UTF-8 string. */
+    cstring(): string;
+    /** Unsigned bit field (MSB first). */
+    ub(n: number): number;
+    /** Signed bit field. */
+    sb(n: number): number;
+    /** Signed 16.16 fixed-point bit field. */
+    fb(n: number): number;
+    /** SWF EncodedU32 / AVM2 variable-length unsigned 32-bit integer. */
+    encodedU32(): number;
+}

package/dist/cjs/io/reader.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteReader = void 0;
+const errors_js_1 = require("../errors.js");
+const utf8Decoder = new TextDecoder('utf-8');
+/**
+ * Little-endian binary reader with SWF bit-field support.
+ *
+ * Bit reads (`ub`, `sb`, `fb`) share an internal bit buffer; any byte-aligned
+ * read implicitly re-aligns to the next byte boundary, as required by the SWF
+ * specification.
+ */
+class ByteReader {
+    bytes;
+    view;
+    pos;
+    end;
+    bitBuf = 0;
+    bitCount = 0;
+    constructor(bytes, start = 0, end = bytes.length) {
+        this.bytes = bytes;
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        this.pos = start;
+        this.end = end;
+    }
+    get remaining() {
+        return this.end - this.pos;
+    }
+    get eof() {
+        return this.pos >= this.end;
+    }
+    need(n) {
+        if (this.pos + n > this.end) {
+            throw new errors_js_1.SwfFormatError(`Unexpected end of data at offset ${this.pos} (need ${n} byte(s), ${this.remaining} left)`);
+        }
+    }
+    align() {
+        this.bitCount = 0;
+        this.bitBuf = 0;
+    }
+    u8() {
+        this.align();
+        this.need(1);
+        return this.bytes[this.pos++];
+    }
+    s8() {
+        const v = this.u8();
+        return v >= 0x80 ? v - 0x100 : v;
+    }
+    u16() {
+        this.align();
+        this.need(2);
+        const v = this.view.getUint16(this.pos, true);
+        this.pos += 2;
+        return v;
+    }
+    s16() {
+        this.align();
+        this.need(2);
+        const v = this.view.getInt16(this.pos, true);
+        this.pos += 2;
+        return v;
+    }
+    u24() {
+        this.align();
+        this.need(3);
+        const b = this.bytes;
+        const v = b[this.pos] | (b[this.pos + 1] << 8) | (b[this.pos + 2] << 16);
+        this.pos += 3;
+        return v;
+    }
+    s24() {
+        const v = this.u24();
+        return v & 0x800000 ? v - 0x1000000 : v;
+    }
+    u32() {
+        this.align();
+        this.need(4);
+        const v = this.view.getUint32(this.pos, true);
+        this.pos += 4;
+        return v;
+    }
+    s32() {
+        this.align();
+        this.need(4);
+        const v = this.view.getInt32(this.pos, true);
+        this.pos += 4;
+        return v;
+    }
+    f32() {
+        this.align();
+        this.need(4);
+        const v = this.view.getFloat32(this.pos, true);
+        this.pos += 4;
+        return v;
+    }
+    f64() {
+        this.align();
+        this.need(8);
+        const v = this.view.getFloat64(this.pos, true);
+        this.pos += 8;
+        return v;
+    }
+    /** 8.8 fixed point. */
+    fixed8() {
+        return this.s16() / 256;
+    }
+    /** 16.16 fixed point. */
+    fixed() {
+        return this.s32() / 65536;
+    }
+    bytesView(n) {
+        this.align();
+        this.need(n);
+        const v = this.bytes.subarray(this.pos, this.pos + n);
+        this.pos += n;
+        return v;
+    }
+    /** Copy of the next `n` bytes. */
+    bytesCopy(n) {
+        return this.bytesView(n).slice();
+    }
+    rest() {
+        return this.bytesView(this.remaining);
+    }
+    /** Null-terminated UTF-8 string. */
+    cstring() {
+        this.align();
+        const start = this.pos;
+        while (this.pos < this.end && this.bytes[this.pos] !== 0)
+            this.pos++;
+        if (this.pos >= this.end)
+            throw new errors_js_1.SwfFormatError(`Unterminated string at offset ${start}`);
+        const s = utf8Decoder.decode(this.bytes.subarray(start, this.pos));
+        this.pos++;
+        return s;
+    }
+    /** Unsigned bit field (MSB first). */
+    ub(n) {
+        let result = 0;
+        for (let i = 0; i < n; i++) {
+            if (this.bitCount === 0) {
+                this.need(1);
+                this.bitBuf = this.bytes[this.pos++];
+                this.bitCount = 8;
+            }
+            this.bitCount--;
+            result = result * 2 + ((this.bitBuf >> this.bitCount) & 1);
+        }
+        return result;
+    }
+    /** Signed bit field. */
+    sb(n) {
+        if (n === 0)
+            return 0;
+        const v = this.ub(n);
+        const sign = 2 ** (n - 1);
+        return v >= sign ? v - 2 * sign : v;
+    }
+    /** Signed 16.16 fixed-point bit field. */
+    fb(n) {
+        return this.sb(n) / 65536;
+    }
+    /** SWF EncodedU32 / AVM2 variable-length unsigned 32-bit integer. */
+    encodedU32() {
+        this.align();
+        let result = 0;
+        let shift = 0;
+        for (let i = 0; i < 5; i++) {
+            this.need(1);
+            const b = this.bytes[this.pos++];
+            result += (b & 0x7f) * 2 ** shift;
+            if ((b & 0x80) === 0)
+                break;
+            shift += 7;
+        }
+        return result >>> 0;
+    }
+}
+exports.ByteReader = ByteReader;

package/dist/cjs/io/writer.d.ts

@@ -0,0 +1,37 @@
+/** Growable little-endian binary writer with SWF bit-field support. */
+export declare class ByteWriter {
+    private buf;
+    private view;
+    length: number;
+    private bitBuf;
+    private bitCount;
+    constructor(initialCapacity?: number);
+    private ensure;
+    /** Flush pending bits (pads the current byte with zeros). */
+    align(): void;
+    u8(v: number): this;
+    s8(v: number): this;
+    u16(v: number): this;
+    s16(v: number): this;
+    u24(v: number): this;
+    s24(v: number): this;
+    u32(v: number): this;
+    s32(v: number): this;
+    f32(v: number): this;
+    f64(v: number): this;
+    fixed8(v: number): this;
+    fixed(v: number): this;
+    bytes(data: Uint8Array): this;
+    cstring(s: string): this;
+    ub(n: number, v: number): this;
+    sb(n: number, v: number): this;
+    fb(n: number, v: number): this;
+    encodedU32(v: number): this;
+    /** Overwrite a little-endian u32 at an absolute offset. */
+    patchU32(offset: number, v: number): void;
+    toBytes(): Uint8Array;
+}
+/** Number of bits needed to store `v` as an unsigned bit field. */
+export declare function unsignedBits(v: number): number;
+/** Number of bits needed to store `v` as a signed bit field. */
+export declare function signedBits(v: number): number;

package/dist/cjs/io/writer.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteWriter = void 0;
+exports.unsignedBits = unsignedBits;
+exports.signedBits = signedBits;
+const utf8Encoder = new TextEncoder();
+/** Growable little-endian binary writer with SWF bit-field support. */
+class ByteWriter {
+    buf;
+    view;
+    length = 0;
+    bitBuf = 0;
+    bitCount = 0;
+    constructor(initialCapacity = 1024) {
+        this.buf = new Uint8Array(Math.max(16, initialCapacity));
+        this.view = new DataView(this.buf.buffer);
+    }
+    ensure(n) {
+        const required = this.length + n;
+        if (required <= this.buf.length)
+            return;
+        let cap = this.buf.length * 2;
+        while (cap < required)
+            cap *= 2;
+        const next = new Uint8Array(cap);
+        next.set(this.buf.subarray(0, this.length));
+        this.buf = next;
+        this.view = new DataView(next.buffer);
+    }
+    /** Flush pending bits (pads the current byte with zeros). */
+    align() {
+        if (this.bitCount > 0) {
+            this.ensure(1);
+            this.buf[this.length++] = (this.bitBuf << (8 - this.bitCount)) & 0xff;
+            this.bitBuf = 0;
+            this.bitCount = 0;
+        }
+    }
+    u8(v) {
+        this.align();
+        this.ensure(1);
+        this.buf[this.length++] = v & 0xff;
+        return this;
+    }
+    s8(v) {
+        return this.u8(v < 0 ? v + 0x100 : v);
+    }
+    u16(v) {
+        this.align();
+        this.ensure(2);
+        this.view.setUint16(this.length, v & 0xffff, true);
+        this.length += 2;
+        return this;
+    }
+    s16(v) {
+        this.align();
+        this.ensure(2);
+        this.view.setInt16(this.length, v, true);
+        this.length += 2;
+        return this;
+    }
+    u24(v) {
+        this.align();
+        this.ensure(3);
+        const x = v & 0xffffff;
+        this.buf[this.length++] = x & 0xff;
+        this.buf[this.length++] = (x >> 8) & 0xff;
+        this.buf[this.length++] = (x >> 16) & 0xff;
+        return this;
+    }
+    s24(v) {
+        return this.u24(v < 0 ? v + 0x1000000 : v);
+    }
+    u32(v) {
+        this.align();
+        this.ensure(4);
+        this.view.setUint32(this.length, v >>> 0, true);
+        this.length += 4;
+        return this;
+    }
+    s32(v) {
+        this.align();
+        this.ensure(4);
+        this.view.setInt32(this.length, v | 0, true);
+        this.length += 4;
+        return this;
+    }
+    f32(v) {
+        this.align();
+        this.ensure(4);
+        this.view.setFloat32(this.length, v, true);
+        this.length += 4;
+        return this;
+    }
+    f64(v) {
+        this.align();
+        this.ensure(8);
+        this.view.setFloat64(this.length, v, true);
+        this.length += 8;
+        return this;
+    }
+    fixed8(v) {
+        return this.s16(Math.round(v * 256));
+    }
+    fixed(v) {
+        return this.s32(Math.round(v * 65536));
+    }
+    bytes(data) {
+        this.align();
+        this.ensure(data.length);
+        this.buf.set(data, this.length);
+        this.length += data.length;
+        return this;
+    }
+    cstring(s) {
+        this.bytes(utf8Encoder.encode(s));
+        return this.u8(0);
+    }
+    ub(n, v) {
+        for (let i = n - 1; i >= 0; i--) {
+            const bit = Math.floor(v / 2 ** i) & 1;
+            this.bitBuf = (this.bitBuf << 1) | bit;
+            this.bitCount++;
+            if (this.bitCount === 8) {
+                this.ensure(1);
+                this.buf[this.length++] = this.bitBuf & 0xff;
+                this.bitBuf = 0;
+                this.bitCount = 0;
+            }
+        }
+        return this;
+    }
+    sb(n, v) {
+        return this.ub(n, v < 0 ? v + 2 ** n : v);
+    }
+    fb(n, v) {
+        return this.sb(n, Math.round(v * 65536));
+    }
+    encodedU32(v) {
+        this.align();
+        let x = v >>> 0;
+        do {
+            let b = x & 0x7f;
+            x = x >>> 7;
+            if (x !== 0)
+                b |= 0x80;
+            this.u8(b);
+        } while (x !== 0);
+        return this;
+    }
+    /** Overwrite a little-endian u32 at an absolute offset. */
+    patchU32(offset, v) {
+        this.view.setUint32(offset, v >>> 0, true);
+    }
+    toBytes() {
+        this.align();
+        return this.buf.slice(0, this.length);
+    }
+}
+exports.ByteWriter = ByteWriter;
+/** Number of bits needed to store `v` as an unsigned bit field. */
+function unsignedBits(v) {
+    let n = 0;
+    while (v > 0) {
+        n++;
+        v = Math.floor(v / 2);
+    }
+    return n;
+}
+/** Number of bits needed to store `v` as a signed bit field. */
+function signedBits(v) {
+    if (v === 0)
+        return 0;
+    return unsignedBits(v < 0 ? -v - 1 : v) + 1;
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/project/pcode-project.d.ts

@@ -0,0 +1,32 @@
+import type { Swf } from '../swf/swf.js';
+export declare const MANIFEST_NAME = "swf-toolkit.json";
+/** Make a class / package name safe as a path segment on all platforms. */
+export declare function safeSegment(s: string): string;
+export interface ExportPcodeResult {
+    outDir: string;
+    files: string[];
+    methodCount: number;
+}
+/** Writes one `.pcode` file per class (plus a manifest) into `outDir`. */
+export declare function exportPcode(swf: Swf, outDir: string): Promise<ExportPcodeResult>;
+/** Splits a P-code document into `method ... end` blocks with their method index. */
+export declare function splitMethodBlocks(text: string): Array<{
+    text: string;
+    startLine: number;
+    methodIndex: number | 'new';
+}>;
+export interface ImportPcodeResult {
+    /** Methods that were re-assembled. */
+    changed: Array<{
+        file: string;
+        methodIndex: number;
+    }>;
+    /** Number of method blocks that were identical to the current SWF. */
+    unchanged: number;
+}
+export interface ImportPcodeOptions {
+    /** Only import these files (paths relative to the project dir). */
+    files?: string[];
+}
+/** Applies edited `.pcode` files from `dir` (created by {@link exportPcode}) to `swf`. */
+export declare function importPcode(swf: Swf, dir: string, options?: ImportPcodeOptions): Promise<ImportPcodeResult>;