swf-toolkit 0.0.0-stage → 0.1.0

package/dist/avm1/project.js

@@ -0,0 +1,81 @@
+/**
+ * AS1/AS2 code blocks (DoAction / DoInitAction) export & import as P-code.
+ */
+import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { TagCode } from '../swf/tag-codes.js';
+import { RawTag } from '../swf/tags.js';
+import { decodeActions, encodeActions, formatActions, parseActions } from './avm1.js';
+/** All AVM1 code blocks of an SWF (main timeline and sprites). */
+export function actionBlocks(swf) {
+    const out = [];
+    const frames = new Map();
+    for (const { tag, parent, index } of swf.walkTags()) {
+        const owner = parent ?? swf;
+        if (tag.code === TagCode.ShowFrame)
+            frames.set(owner, (frames.get(owner) ?? 0) + 1);
+        if (!(tag instanceof RawTag) || (tag.code !== TagCode.DoAction && tag.code !== TagCode.DoInitAction))
+            continue;
+        const scope = parent ? `sprite${parent.spriteId}` : 'root';
+        const init = tag.code === 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;
+}
+export function disassembleBlock(b) {
+    return formatActions(decodeActions(b.tag.data.subarray(b.offset)));
+}
+export function assembleBlock(b, text) {
+    const code = encodeActions(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;
+}
+export async function exportAs2(swf, dir) {
+    await 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 = join(dir, `${b.key}.as2pcode`);
+        await writeFile(p, text, 'utf8');
+        files.push(p);
+    }
+    return files;
+}
+/** Re-assembles blocks whose files changed. Returns the keys that were updated. */
+export async function importAs2(swf, dir) {
+    const present = new Set(await readdir(dir));
+    const changed = [];
+    for (const b of actionBlocks(swf)) {
+        const name = `${b.key}.as2pcode`;
+        if (!present.has(name))
+            continue;
+        const text = await readFile(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/abc/abc-file.d.ts

@@ -0,0 +1,168 @@
+export interface NamespaceInfo {
+    kind: number;
+    /** String pool index (0 = no name). */
+    name: number;
+}
+/**
+ * A multiname pool entry. Only the fields relevant for `kind` are meaningful:
+ * - QName(A): ns, name
+ * - RTQName(A): name
+ * - RTQNameL(A): –
+ * - Multiname(A): name, nsSet
+ * - MultinameL(A): nsSet
+ * - TypeName: base, params
+ */
+export interface MultinameInfo {
+    kind: number;
+    ns: number;
+    name: number;
+    nsSet: number;
+    base: number;
+    params: number[];
+}
+export interface OptionalParam {
+    kind: number;
+    value: number;
+}
+export interface MethodInfo {
+    paramTypes: number[];
+    returnType: number;
+    name: number;
+    flags: number;
+    optional: OptionalParam[];
+    paramNames: number[];
+}
+export interface MetadataInfo {
+    name: number;
+    keys: number[];
+    values: number[];
+}
+export interface Trait {
+    name: number;
+    kind: number;
+    /** Upper 4 bits of the kind byte (Final / Override / Metadata). */
+    attrs: number;
+    /** slot_id for Slot/Const/Class/Function, disp_id for Method/Getter/Setter. */
+    id: number;
+    /** Slot/Const: type multiname. */
+    typeName: number;
+    /** Slot/Const: default value index (0 = none). */
+    valueIndex: number;
+    /** Slot/Const: default value kind (only if valueIndex != 0). */
+    valueKind: number;
+    /** Class: class index. */
+    classIndex: number;
+    /** Method/Getter/Setter/Function: method index. */
+    method: number;
+    metadata: number[];
+}
+export interface InstanceInfo {
+    name: number;
+    superName: number;
+    flags: number;
+    protectedNs: number;
+    interfaces: number[];
+    iinit: number;
+    traits: Trait[];
+}
+export interface ClassInfo {
+    cinit: number;
+    traits: Trait[];
+}
+export interface ScriptInfo {
+    init: number;
+    traits: Trait[];
+}
+export interface ExceptionInfo {
+    from: number;
+    to: number;
+    target: number;
+    excType: number;
+    varName: number;
+}
+export interface MethodBody {
+    method: number;
+    maxStack: number;
+    localCount: number;
+    initScopeDepth: number;
+    maxScopeDepth: number;
+    code: Uint8Array;
+    exceptions: ExceptionInfo[];
+    traits: Trait[];
+}
+export declare function emptyMultiname(kind?: number): MultinameInfo;
+export declare function newTrait(partial: Partial<Trait> & {
+    name: number;
+    kind: number;
+}): Trait;
+/** A parsed ActionScript Byte Code (ABC) file. */
+export declare class AbcFile {
+    minorVersion: number;
+    majorVersion: number;
+    ints: number[];
+    uints: number[];
+    doubles: number[];
+    strings: string[];
+    namespaces: NamespaceInfo[];
+    nsSets: number[][];
+    multinames: MultinameInfo[];
+    methods: MethodInfo[];
+    metadata: MetadataInfo[];
+    instances: InstanceInfo[];
+    classes: ClassInfo[];
+    scripts: ScriptInfo[];
+    bodies: MethodBody[];
+    /** Raw bytes of strings that are not valid UTF-8, keyed by pool index. */
+    private rawStrings;
+    /** Pools whose count was written as 1 (instead of 0) while empty; preserved for exact round-trips. */
+    private onePools;
+    private readonly intCache;
+    private readonly uintCache;
+    private readonly doubleCache;
+    private readonly stringCache;
+    private readonly nsCache;
+    private readonly nsSetCache;
+    private readonly mnCache;
+    private bodyIndex;
+    private bodyIndexSize;
+    static parse(bytes: Uint8Array): AbcFile;
+    toBytes(): Uint8Array;
+    /** String pool index for `s` (adds it if missing). */
+    string(s: string): number;
+    int(v: number): number;
+    uint(v: number): number;
+    double(v: number): number;
+    /** Namespace pool index. `PrivateNs` entries are always created fresh unless `reuse` is set. */
+    namespace(kind: number, name: string | number, reuse?: boolean): number;
+    packageNamespace(name: string): number;
+    nsSet(namespaces: number[]): number;
+    multiname(info: Partial<MultinameInfo> & {
+        kind: number;
+    }): number;
+    /** QName multiname index. `ns` may be a namespace index or a package name. */
+    qname(ns: number | string, name: string): number;
+    /** QName for a fully qualified name like "flash.display.Sprite" (or "flash.display:Sprite"). */
+    qnameFor(qualified: string): number;
+    /** Method body for a method index, if the method has one. */
+    methodBody(methodIndex: number): MethodBody | undefined;
+    /** Namespace URI string (empty for the public/unnamed namespace). */
+    namespaceName(nsIndex: number): string;
+    /** Local name of a multiname ("*" if any). */
+    multinameName(mnIndex: number): string;
+    /**
+     * Fully qualified dotted name of a multiname, e.g. "flash.display.Sprite".
+     * For non-QName multinames this is just the local name.
+     */
+    qualifiedName(mnIndex: number): string;
+    /** Fully qualified name of class `classIndex`. */
+    className(classIndex: number): string;
+    /** Class index by fully qualified name ("com.example.Foo" or "com.example:Foo"); -1 if not found. */
+    findClass(qualified: string): number;
+    /** Names of all classes defined in this ABC. */
+    classNames(): string[];
+}
+/** Split "a.b.C" / "a.b:C" into package and local name. */
+export declare function splitQualifiedName(qualified: string): {
+    pkg: string;
+    name: string;
+};