swf-toolkit 0.0.0-stage → 0.1.0

package/dist/cjs/swf/tag-codes.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHARACTER_DEFINING_TAGS = exports.TagCode = void 0;
+exports.tagName = tagName;
+/** SWF tag codes (SWF File Format Specification v19). */
+exports.TagCode = {
+    End: 0,
+    ShowFrame: 1,
+    DefineShape: 2,
+    FreeCharacter: 3,
+    PlaceObject: 4,
+    RemoveObject: 5,
+    DefineBits: 6,
+    DefineButton: 7,
+    JPEGTables: 8,
+    SetBackgroundColor: 9,
+    DefineFont: 10,
+    DefineText: 11,
+    DoAction: 12,
+    DefineFontInfo: 13,
+    DefineSound: 14,
+    StartSound: 15,
+    DefineButtonSound: 17,
+    SoundStreamHead: 18,
+    SoundStreamBlock: 19,
+    DefineBitsLossless: 20,
+    DefineBitsJPEG2: 21,
+    DefineShape2: 22,
+    DefineButtonCxform: 23,
+    Protect: 24,
+    PlaceObject2: 26,
+    RemoveObject2: 28,
+    DefineShape3: 32,
+    DefineText2: 33,
+    DefineButton2: 34,
+    DefineBitsJPEG3: 35,
+    DefineBitsLossless2: 36,
+    DefineEditText: 37,
+    DefineSprite: 39,
+    ProductInfo: 41,
+    FrameLabel: 43,
+    SoundStreamHead2: 45,
+    DefineMorphShape: 46,
+    DefineFont2: 48,
+    ExportAssets: 56,
+    ImportAssets: 57,
+    EnableDebugger: 58,
+    DoInitAction: 59,
+    DefineVideoStream: 60,
+    VideoFrame: 61,
+    DefineFontInfo2: 62,
+    DebugID: 63,
+    EnableDebugger2: 64,
+    ScriptLimits: 65,
+    SetTabIndex: 66,
+    FileAttributes: 69,
+    PlaceObject3: 70,
+    ImportAssets2: 71,
+    DoABC: 72,
+    DefineFontAlignZones: 73,
+    CSMTextSettings: 74,
+    DefineFont3: 75,
+    SymbolClass: 76,
+    Metadata: 77,
+    DefineScalingGrid: 78,
+    DoABC2: 82,
+    DefineShape4: 83,
+    DefineMorphShape2: 84,
+    DefineSceneAndFrameLabelData: 86,
+    DefineBinaryData: 87,
+    DefineFontName: 88,
+    StartSound2: 89,
+    DefineBitsJPEG4: 90,
+    DefineFont4: 91,
+    EnableTelemetry: 93,
+    PlaceObject4: 94,
+};
+const NAMES = new Map(Object.entries(exports.TagCode).map(([k, v]) => [v, k]));
+function tagName(code) {
+    return NAMES.get(code) ?? `Unknown(${code})`;
+}
+/** Tags whose body starts with the u16 id of the character they define. */
+exports.CHARACTER_DEFINING_TAGS = new Set([
+    exports.TagCode.DefineShape,
+    exports.TagCode.DefineBits,
+    exports.TagCode.DefineButton,
+    exports.TagCode.DefineFont,
+    exports.TagCode.DefineText,
+    exports.TagCode.DefineSound,
+    exports.TagCode.DefineBitsLossless,
+    exports.TagCode.DefineBitsJPEG2,
+    exports.TagCode.DefineShape2,
+    exports.TagCode.DefineShape3,
+    exports.TagCode.DefineText2,
+    exports.TagCode.DefineButton2,
+    exports.TagCode.DefineBitsJPEG3,
+    exports.TagCode.DefineBitsLossless2,
+    exports.TagCode.DefineEditText,
+    exports.TagCode.DefineSprite,
+    exports.TagCode.DefineMorphShape,
+    exports.TagCode.DefineFont2,
+    exports.TagCode.DefineVideoStream,
+    exports.TagCode.DefineFont3,
+    exports.TagCode.DefineShape4,
+    exports.TagCode.DefineMorphShape2,
+    exports.TagCode.DefineBinaryData,
+    exports.TagCode.DefineBitsJPEG4,
+    exports.TagCode.DefineFont4,
+]);

package/dist/cjs/swf/tags.d.ts

@@ -0,0 +1,118 @@
+import { ByteWriter } from '../io/writer.js';
+import { AbcFile } from '../abc/abc-file.js';
+/** Base class for all SWF tags. */
+export declare abstract class Tag {
+    abstract readonly code: number;
+    /**
+     * Write this tag with a long (6-byte) record header even if its body is
+     * shorter than 63 bytes. Set automatically when parsed from a file that
+     * used the long form, so unmodified files round-trip byte-for-byte.
+     */
+    longHeader: boolean;
+    get name(): string;
+    /** Serialised tag body (without the record header). */
+    abstract encodeBody(): Uint8Array;
+    /** Character id for character-defining tags, otherwise `undefined`. */
+    get characterId(): number | undefined;
+}
+/** A tag kept as opaque bytes. Every tag type not modelled explicitly is a RawTag. */
+export declare class RawTag extends Tag {
+    code: number;
+    data: Uint8Array;
+    constructor(code: number, data: Uint8Array);
+    get characterId(): number | undefined;
+    /** Change the character id of a character-defining tag in place. */
+    setCharacterId(id: number): void;
+    encodeBody(): Uint8Array;
+}
+/**
+ * DoABC (72) / DoABC2 (82): an ActionScript 3 bytecode block.
+ *
+ * The ABC payload is parsed lazily on first access to {@link abc}. As long as
+ * it has not been accessed, the original bytes are written back untouched.
+ */
+export declare class DoABCTag extends Tag {
+    readonly code: number;
+    /** DoABC2 flags. 1 = kDoAbcLazyInitializeFlag. */
+    flags: number;
+    /** DoABC2 name. */
+    abcName: string;
+    private raw;
+    private parsed;
+    constructor(code: number, flags: number, abcName: string, abc: Uint8Array | AbcFile);
+    static create(abc: AbcFile, name?: string, flags?: number): DoABCTag;
+    /** Parsed ABC file. Parsing happens once, on first access. */
+    get abc(): AbcFile;
+    set abc(value: AbcFile);
+    /** True once the ABC has been parsed (and will therefore be re-serialised on save). */
+    get isParsed(): boolean;
+    /** Raw ABC bytes (serialises the parsed ABC if needed). */
+    abcBytes(): Uint8Array;
+    encodeBody(): Uint8Array;
+}
+export interface SymbolEntry {
+    id: number;
+    name: string;
+}
+/** SymbolClass (76) and ExportAssets (56): character id ↔ name mappings. */
+export declare class SymbolTableTag extends Tag {
+    readonly code: number;
+    symbols: SymbolEntry[];
+    constructor(code: number, symbols: SymbolEntry[]);
+    encodeBody(): Uint8Array;
+}
+/** DefineSprite (39): a movie clip with its own control-tag timeline. */
+export declare class DefineSpriteTag extends Tag {
+    spriteId: number;
+    frameCount: number;
+    tags: Tag[];
+    /** Bytes after the nested End tag (normally empty). */
+    trailing: Uint8Array;
+    readonly code: 39;
+    constructor(spriteId: number, frameCount: number, tags: Tag[], 
+    /** Bytes after the nested End tag (normally empty). */
+    trailing?: Uint8Array);
+    get characterId(): number;
+    encodeBody(): Uint8Array;
+}
+/** DefineBinaryData (87). */
+export declare class DefineBinaryDataTag extends Tag {
+    id: number;
+    data: Uint8Array;
+    reserved: number;
+    readonly code: 87;
+    constructor(id: number, data: Uint8Array, reserved?: number);
+    get characterId(): number;
+    encodeBody(): Uint8Array;
+}
+/** Metadata (77): XMP/RDF XML string. */
+export declare class MetadataTag extends Tag {
+    xml: string;
+    readonly code: 77;
+    constructor(xml: string);
+    encodeBody(): Uint8Array;
+}
+/** FileAttributes (69). */
+export declare class FileAttributesTag extends Tag {
+    flags: number;
+    readonly code: 69;
+    constructor(flags: number);
+    get useDirectBlit(): boolean;
+    get useGPU(): boolean;
+    get hasMetadata(): boolean;
+    get actionScript3(): boolean;
+    set actionScript3(v: boolean);
+    get useNetwork(): boolean;
+    set useNetwork(v: boolean);
+    encodeBody(): Uint8Array;
+}
+/**
+ * Reads a tag stream until (and including) the End tag or the end of data.
+ * Returns the tags and the offset right after the last consumed byte.
+ */
+export declare function readTags(bytes: Uint8Array, start: number, end: number): {
+    tags: Tag[];
+    end: number;
+};
+export declare function writeTag(w: ByteWriter, tag: Tag): void;
+export declare function writeTags(w: ByteWriter, tags: readonly Tag[]): void;

package/dist/cjs/swf/tags.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileAttributesTag = exports.MetadataTag = exports.DefineBinaryDataTag = exports.DefineSpriteTag = exports.SymbolTableTag = exports.DoABCTag = exports.RawTag = exports.Tag = void 0;
+exports.readTags = readTags;
+exports.writeTag = writeTag;
+exports.writeTags = writeTags;
+const reader_js_1 = require("../io/reader.js");
+const writer_js_1 = require("../io/writer.js");
+const abc_file_js_1 = require("../abc/abc-file.js");
+const tag_codes_js_1 = require("./tag-codes.js");
+/** Base class for all SWF tags. */
+class Tag {
+    /**
+     * Write this tag with a long (6-byte) record header even if its body is
+     * shorter than 63 bytes. Set automatically when parsed from a file that
+     * used the long form, so unmodified files round-trip byte-for-byte.
+     */
+    longHeader = false;
+    get name() {
+        return (0, tag_codes_js_1.tagName)(this.code);
+    }
+    /** Character id for character-defining tags, otherwise `undefined`. */
+    get characterId() {
+        return undefined;
+    }
+}
+exports.Tag = Tag;
+/** A tag kept as opaque bytes. Every tag type not modelled explicitly is a RawTag. */
+class RawTag extends Tag {
+    code;
+    data;
+    constructor(code, data) {
+        super();
+        this.code = code;
+        this.data = data;
+    }
+    get characterId() {
+        if (tag_codes_js_1.CHARACTER_DEFINING_TAGS.has(this.code) && this.data.length >= 2) {
+            return this.data[0] | (this.data[1] << 8);
+        }
+        return undefined;
+    }
+    /** Change the character id of a character-defining tag in place. */
+    setCharacterId(id) {
+        if (!tag_codes_js_1.CHARACTER_DEFINING_TAGS.has(this.code))
+            throw new Error(`${this.name} does not define a character`);
+        this.data = this.data.slice();
+        this.data[0] = id & 0xff;
+        this.data[1] = (id >> 8) & 0xff;
+    }
+    encodeBody() {
+        return this.data;
+    }
+}
+exports.RawTag = RawTag;
+/**
+ * DoABC (72) / DoABC2 (82): an ActionScript 3 bytecode block.
+ *
+ * The ABC payload is parsed lazily on first access to {@link abc}. As long as
+ * it has not been accessed, the original bytes are written back untouched.
+ */
+class DoABCTag extends Tag {
+    code;
+    /** DoABC2 flags. 1 = kDoAbcLazyInitializeFlag. */
+    flags;
+    /** DoABC2 name. */
+    abcName;
+    raw;
+    parsed;
+    constructor(code, flags, abcName, abc) {
+        super();
+        this.code = code;
+        this.flags = flags;
+        this.abcName = abcName;
+        if (abc instanceof abc_file_js_1.AbcFile)
+            this.parsed = abc;
+        else
+            this.raw = abc;
+    }
+    static create(abc, name = '', flags = 1) {
+        return new DoABCTag(tag_codes_js_1.TagCode.DoABC2, flags, name, abc);
+    }
+    /** Parsed ABC file. Parsing happens once, on first access. */
+    get abc() {
+        if (!this.parsed) {
+            this.parsed = abc_file_js_1.AbcFile.parse(this.raw);
+            this.raw = undefined;
+        }
+        return this.parsed;
+    }
+    set abc(value) {
+        this.parsed = value;
+        this.raw = undefined;
+    }
+    /** True once the ABC has been parsed (and will therefore be re-serialised on save). */
+    get isParsed() {
+        return this.parsed !== undefined;
+    }
+    /** Raw ABC bytes (serialises the parsed ABC if needed). */
+    abcBytes() {
+        return this.parsed ? this.parsed.toBytes() : this.raw;
+    }
+    encodeBody() {
+        const abc = this.abcBytes();
+        if (this.code === tag_codes_js_1.TagCode.DoABC)
+            return abc;
+        const w = new writer_js_1.ByteWriter(abc.length + this.abcName.length + 8);
+        w.u32(this.flags);
+        w.cstring(this.abcName);
+        w.bytes(abc);
+        return w.toBytes();
+    }
+}
+exports.DoABCTag = DoABCTag;
+/** SymbolClass (76) and ExportAssets (56): character id ↔ name mappings. */
+class SymbolTableTag extends Tag {
+    code;
+    symbols;
+    constructor(code, symbols) {
+        super();
+        this.code = code;
+        this.symbols = symbols;
+    }
+    encodeBody() {
+        const w = new writer_js_1.ByteWriter();
+        w.u16(this.symbols.length);
+        for (const s of this.symbols) {
+            w.u16(s.id);
+            w.cstring(s.name);
+        }
+        return w.toBytes();
+    }
+}
+exports.SymbolTableTag = SymbolTableTag;
+/** DefineSprite (39): a movie clip with its own control-tag timeline. */
+class DefineSpriteTag extends Tag {
+    spriteId;
+    frameCount;
+    tags;
+    trailing;
+    code = tag_codes_js_1.TagCode.DefineSprite;
+    constructor(spriteId, frameCount, tags, 
+    /** Bytes after the nested End tag (normally empty). */
+    trailing = new Uint8Array(0)) {
+        super();
+        this.spriteId = spriteId;
+        this.frameCount = frameCount;
+        this.tags = tags;
+        this.trailing = trailing;
+    }
+    get characterId() {
+        return this.spriteId;
+    }
+    encodeBody() {
+        const w = new writer_js_1.ByteWriter();
+        w.u16(this.spriteId);
+        w.u16(this.frameCount);
+        writeTags(w, this.tags);
+        w.bytes(this.trailing);
+        return w.toBytes();
+    }
+}
+exports.DefineSpriteTag = DefineSpriteTag;
+/** DefineBinaryData (87). */
+class DefineBinaryDataTag extends Tag {
+    id;
+    data;
+    reserved;
+    code = tag_codes_js_1.TagCode.DefineBinaryData;
+    constructor(id, data, reserved = 0) {
+        super();
+        this.id = id;
+        this.data = data;
+        this.reserved = reserved;
+    }
+    get characterId() {
+        return this.id;
+    }
+    encodeBody() {
+        const w = new writer_js_1.ByteWriter(this.data.length + 6);
+        w.u16(this.id);
+        w.u32(this.reserved);
+        w.bytes(this.data);
+        return w.toBytes();
+    }
+}
+exports.DefineBinaryDataTag = DefineBinaryDataTag;
+/** Metadata (77): XMP/RDF XML string. */
+class MetadataTag extends Tag {
+    xml;
+    code = tag_codes_js_1.TagCode.Metadata;
+    constructor(xml) {
+        super();
+        this.xml = xml;
+    }
+    encodeBody() {
+        return new writer_js_1.ByteWriter().cstring(this.xml).toBytes();
+    }
+}
+exports.MetadataTag = MetadataTag;
+/** FileAttributes (69). */
+class FileAttributesTag extends Tag {
+    flags;
+    code = tag_codes_js_1.TagCode.FileAttributes;
+    constructor(flags) {
+        super();
+        this.flags = flags;
+    }
+    get useDirectBlit() {
+        return (this.flags & 0x40) !== 0;
+    }
+    get useGPU() {
+        return (this.flags & 0x20) !== 0;
+    }
+    get hasMetadata() {
+        return (this.flags & 0x10) !== 0;
+    }
+    get actionScript3() {
+        return (this.flags & 0x08) !== 0;
+    }
+    set actionScript3(v) {
+        this.flags = v ? this.flags | 0x08 : this.flags & ~0x08;
+    }
+    get useNetwork() {
+        return (this.flags & 0x01) !== 0;
+    }
+    set useNetwork(v) {
+        this.flags = v ? this.flags | 0x01 : this.flags & ~0x01;
+    }
+    encodeBody() {
+        return new writer_js_1.ByteWriter(4).u32(this.flags).toBytes();
+    }
+}
+exports.FileAttributesTag = FileAttributesTag;
+// ---------------------------------------------------------------------------
+// Tag stream parsing / writing
+// ---------------------------------------------------------------------------
+function decodeTag(code, body) {
+    const r = new reader_js_1.ByteReader(body);
+    switch (code) {
+        case tag_codes_js_1.TagCode.DoABC:
+            return new DoABCTag(code, 0, '', body);
+        case tag_codes_js_1.TagCode.DoABC2: {
+            const flags = r.u32();
+            const name = r.cstring();
+            return new DoABCTag(code, flags, name, r.rest());
+        }
+        case tag_codes_js_1.TagCode.SymbolClass:
+        case tag_codes_js_1.TagCode.ExportAssets: {
+            const count = r.u16();
+            const symbols = [];
+            for (let i = 0; i < count; i++)
+                symbols.push({ id: r.u16(), name: r.cstring() });
+            if (!r.eof)
+                return new RawTag(code, body);
+            return new SymbolTableTag(code, symbols);
+        }
+        case tag_codes_js_1.TagCode.DefineSprite: {
+            const id = r.u16();
+            const frameCount = r.u16();
+            const { tags, end } = readTags(body, r.pos, body.length);
+            return new DefineSpriteTag(id, frameCount, tags, body.slice(end));
+        }
+        case tag_codes_js_1.TagCode.DefineBinaryData: {
+            const id = r.u16();
+            const reserved = r.u32();
+            return new DefineBinaryDataTag(id, r.rest(), reserved);
+        }
+        case tag_codes_js_1.TagCode.Metadata: {
+            const xml = r.cstring();
+            if (!r.eof)
+                return new RawTag(code, body);
+            return new MetadataTag(xml);
+        }
+        case tag_codes_js_1.TagCode.FileAttributes:
+            if (body.length !== 4)
+                return new RawTag(code, body);
+            return new FileAttributesTag(r.u32());
+        default:
+            return new RawTag(code, body);
+    }
+}
+/**
+ * Reads a tag stream until (and including) the End tag or the end of data.
+ * Returns the tags and the offset right after the last consumed byte.
+ */
+function readTags(bytes, start, end) {
+    const r = new reader_js_1.ByteReader(bytes, start, end);
+    const tags = [];
+    while (r.remaining >= 2) {
+        const codeAndLength = r.u16();
+        const code = codeAndLength >> 6;
+        let length = codeAndLength & 0x3f;
+        const long = length === 0x3f;
+        if (long) {
+            if (r.remaining < 4)
+                break;
+            length = r.u32();
+        }
+        // Clamp truncated tags instead of failing the whole file.
+        const body = r.bytesView(Math.min(length, r.remaining)).slice();
+        let tag;
+        try {
+            tag = decodeTag(code, body);
+        }
+        catch {
+            tag = new RawTag(code, body);
+        }
+        tag.longHeader = long;
+        tags.push(tag);
+        if (code === tag_codes_js_1.TagCode.End)
+            break;
+    }
+    return { tags, end: r.pos };
+}
+function writeTag(w, tag) {
+    const body = tag.encodeBody();
+    if (body.length >= 0x3f || tag.longHeader) {
+        w.u16((tag.code << 6) | 0x3f);
+        w.u32(body.length);
+    }
+    else {
+        w.u16((tag.code << 6) | body.length);
+    }
+    w.bytes(body);
+}
+function writeTags(w, tags) {
+    for (const t of tags)
+        writeTag(w, t);
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};