swf-toolkit 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,29 @@
+/**
+ * Whole-program helpers: compile AS3 sources into a fresh ABC / SWF.
+ */
+import { AbcFile } from '../abc/abc-file.js';
+import { Swf } from '../swf/swf.js';
+import { type CompileClassResult } from './class-compiler.js';
+export interface SourceFile {
+    /** File name (used in error messages). */
+    name: string;
+    text: string;
+}
+/** Compiles source files into `abc` (a new ABC when omitted). */
+export declare function compileSources(sources: SourceFile[], abc?: AbcFile): {
+    abc: AbcFile;
+    result: CompileClassResult;
+};
+export interface CreateSwfOptions {
+    /** Fully qualified document class (instantiated as the main timeline). */
+    documentClass: string;
+    width?: number;
+    height?: number;
+    frameRate?: number;
+    /** SWF version (default 15). */
+    version?: number;
+    /** RGB background colour (default white). */
+    background?: number;
+}
+/** Builds a minimal AS3 SWF around an ABC. */
+export declare function createSwf(abc: AbcFile, options: CreateSwfOptions): Swf;

package/dist/cjs/compiler/program.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileSources = compileSources;
+exports.createSwf = createSwf;
+/**
+ * Whole-program helpers: compile AS3 sources into a fresh ABC / SWF.
+ */
+const abc_file_js_1 = require("../abc/abc-file.js");
+const interner_js_1 = require("../abc/interner.js");
+const swf_js_1 = require("../swf/swf.js");
+const tag_codes_js_1 = require("../swf/tag-codes.js");
+const tags_js_1 = require("../swf/tags.js");
+const class_compiler_js_1 = require("./class-compiler.js");
+/** Compiles source files into `abc` (a new ABC when omitted). */
+function compileSources(sources, abc = new abc_file_js_1.AbcFile()) {
+    const interner = new interner_js_1.Interner(abc);
+    const result = { changes: [] };
+    for (const f of sources) {
+        const r = (0, class_compiler_js_1.compileClassSource)(abc, f.text, { source: f.name, interner, baseline: null });
+        result.changes.push(...r.changes);
+    }
+    return { abc, result };
+}
+/** Builds a minimal AS3 SWF around an ABC. */
+function createSwf(abc, options) {
+    const bg = options.background ?? 0xffffff;
+    const swf = new swf_js_1.Swf({
+        version: options.version ?? 15,
+        compression: 'zlib',
+        frameSize: { xMin: 0, xMax: (options.width ?? 550) * 20, yMin: 0, yMax: (options.height ?? 400) * 20 },
+        frameRate: options.frameRate ?? 24,
+        frameCount: 1,
+    });
+    swf.tags.push(new tags_js_1.FileAttributesTag(0x08 | 0x01), new tags_js_1.RawTag(tag_codes_js_1.TagCode.SetBackgroundColor, new Uint8Array([(bg >> 16) & 0xff, (bg >> 8) & 0xff, bg & 0xff])), tags_js_1.DoABCTag.create(abc, 'main'), new tags_js_1.SymbolTableTag(tag_codes_js_1.TagCode.SymbolClass, [{ id: 0, name: options.documentClass }]), new tags_js_1.RawTag(tag_codes_js_1.TagCode.ShowFrame, new Uint8Array(0)), new tags_js_1.RawTag(tag_codes_js_1.TagCode.End, new Uint8Array(0)));
+    return swf;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Builds the name-resolution environment (open namespaces, type resolution)
+ * for compiling code that belongs to a class of an existing ABC.
+ */
+import type { AbcFile } from '../abc/abc-file.js';
+import type { Interner } from '../abc/interner.js';
+import { type ClassScope } from './codegen.js';
+export interface ScopeInput {
+    abc: AbcFile;
+    pool: Interner;
+    pkg: string;
+    imports: string[];
+    useNamespaces: string[];
+    /** Existing class index, or -1 for code outside an existing class. */
+    classIndex: number;
+    /** Local member names of the class (they shadow imports). */
+    memberNames: Set<string>;
+    source?: string;
+}
+export declare function buildClassScope(input: ScopeInput): ClassScope;
+/** Namespace for a member declared with the given access keyword. */
+export declare function memberNamespace(scope: ClassScope, access: string): number;

package/dist/cjs/compiler/scope.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildClassScope = buildClassScope;
+exports.memberNamespace = memberNamespace;
+const code_js_1 = require("../abc/code.js");
+const constants_js_1 = require("../abc/constants.js");
+const model_js_1 = require("../abc/model.js");
+const codegen_js_1 = require("./codegen.js");
+const AS3_NS = 'http://adobe.com/AS3/2006/builtin';
+/** Package names → short names, harvested from QNames in the constant pool. */
+function knownQNames(abc) {
+    const map = new Map();
+    for (const m of abc.multinames) {
+        if (m.kind !== constants_js_1.MultinameKind.QName)
+            continue;
+        const ns = abc.namespaces[m.ns];
+        if (!ns || ns.kind !== constants_js_1.NamespaceKind.PackageNamespace)
+            continue;
+        const name = abc.strings[m.name];
+        if (!name)
+            continue;
+        const pkg = abc.strings[ns.name] ?? '';
+        let set = map.get(name);
+        if (!set)
+            map.set(name, (set = new Set()));
+        set.add(pkg);
+    }
+    return map;
+}
+const knownCache = new WeakMap();
+/** The namespace set most used by a class's existing code (its "open namespaces"). */
+function classNsSet(abc, classIndex) {
+    const counts = new Map();
+    for (const r of (0, model_js_1.classMethods)(abc, classIndex, false)) {
+        const body = abc.methodBody(r.methodIndex);
+        if (!body)
+            continue;
+        let items;
+        try {
+            items = (0, code_js_1.decodeCode)(body.code, body.exceptions).items;
+        }
+        catch {
+            continue;
+        }
+        for (const it of items) {
+            if (it.type !== 'op')
+                continue;
+            for (const a of it.args) {
+                const m = abc.multinames[a];
+                if (m && (m.kind === constants_js_1.MultinameKind.Multiname || m.kind === constants_js_1.MultinameKind.MultinameL) && m.nsSet) {
+                    counts.set(m.nsSet, (counts.get(m.nsSet) ?? 0) + 1);
+                }
+            }
+        }
+    }
+    let best = -1;
+    for (const [s, n] of counts)
+        if (best < 0 || n > counts.get(best))
+            best = s;
+    return best >= 0 ? [...abc.nsSets[best]] : undefined;
+}
+function lastSegment(uri) {
+    return uri.split(/[/:]/).filter(Boolean).pop() ?? '';
+}
+function buildClassScope(input) {
+    const { abc, pool, pkg, classIndex } = input;
+    const pkgNs = (p) => pool.namespace(constants_js_1.NamespaceKind.PackageNamespace, p);
+    const inst = classIndex >= 0 ? abc.instances[classIndex] : undefined;
+    // Namespaces of the class.
+    let privateNs;
+    const findPrivate = (traits) => {
+        for (const t of traits) {
+            const m = abc.multinames[t.name];
+            const ns = m ? abc.namespaces[m.ns] : undefined;
+            if (ns && ns.kind === constants_js_1.NamespaceKind.PrivateNs && privateNs === undefined)
+                privateNs = m.ns;
+        }
+    };
+    if (inst) {
+        findPrivate(inst.traits);
+        findPrivate(abc.classes[classIndex].traits);
+    }
+    const existingSet = classIndex >= 0 ? classNsSet(abc, classIndex) : undefined;
+    if (privateNs === undefined && existingSet)
+        privateNs = existingSet.find((n) => abc.namespaces[n]?.kind === constants_js_1.NamespaceKind.PrivateNs);
+    if (privateNs === undefined) {
+        const cname = inst ? abc.multinameName(inst.name) : 'script';
+        privateNs = pool.addNs(constants_js_1.NamespaceKind.PrivateNs, pool.string(pkg ? `${pkg}:${cname}` : cname));
+    }
+    const protectedNs = inst && inst.protectedNs ? inst.protectedNs : undefined;
+    let staticProtectedNs;
+    if (existingSet)
+        staticProtectedNs = existingSet.find((n) => abc.namespaces[n]?.kind === constants_js_1.NamespaceKind.StaticProtectedNs);
+    if (staticProtectedNs === undefined && inst) {
+        for (const t of abc.classes[classIndex].traits) {
+            const m = abc.multinames[t.name];
+            if (m && abc.namespaces[m.ns]?.kind === constants_js_1.NamespaceKind.StaticProtectedNs)
+                staticProtectedNs = m.ns;
+        }
+    }
+    if (staticProtectedNs === undefined && inst && protectedNs) {
+        staticProtectedNs = pool.namespace(constants_js_1.NamespaceKind.StaticProtectedNs, abc.strings[abc.namespaces[protectedNs].name] ?? '');
+    }
+    const custom = new Map();
+    abc.namespaces.forEach((ns, i) => {
+        if (i === 0 || ns.kind !== constants_js_1.NamespaceKind.Namespace)
+            return;
+        const uri = abc.strings[ns.name] ?? '';
+        const seg = lastSegment(uri);
+        if (seg && !custom.has(seg))
+            custom.set(seg, i);
+    });
+    // Open namespace set.
+    const set = existingSet ? [...existingSet] : [];
+    const add = (n) => {
+        if (n !== undefined && !set.includes(n))
+            set.push(n);
+    };
+    add(privateNs);
+    add(pkgNs(''));
+    add(pkgNs(pkg));
+    add(pool.namespace(constants_js_1.NamespaceKind.PackageInternalNs, pkg));
+    add(protectedNs);
+    add(staticProtectedNs);
+    // Every namespace the class's own members live in (static protected, custom...).
+    if (inst) {
+        for (const t of [...inst.traits, ...abc.classes[classIndex].traits]) {
+            const m = abc.multinames[t.name];
+            if (m && (m.kind === constants_js_1.MultinameKind.QName || m.kind === constants_js_1.MultinameKind.QNameA) && m.ns)
+                add(m.ns);
+        }
+    }
+    add(pool.namespace(constants_js_1.NamespaceKind.Namespace, AS3_NS));
+    for (const imp of input.imports) {
+        const dot = imp.lastIndexOf('.');
+        if (dot > 0)
+            add(pkgNs(imp.slice(0, dot)));
+    }
+    for (const u of input.useNamespaces)
+        add(custom.get(lastSegment(u)) ?? custom.get(u));
+    const openNsSet = pool.nsSet(set);
+    // Type resolution.
+    let known = knownCache.get(abc);
+    if (!known)
+        knownCache.set(abc, (known = knownQNames(abc)));
+    const definedClasses = new Map();
+    for (let c = 0; c < abc.instances.length; c++) {
+        const q = abc.className(c);
+        const dot = q.lastIndexOf('.');
+        const short = dot >= 0 ? q.slice(dot + 1) : q;
+        let s = definedClasses.get(short);
+        if (!s)
+            definedClasses.set(short, (s = new Set()));
+        s.add(dot >= 0 ? q.slice(0, dot) : '');
+    }
+    const explicitImports = new Map();
+    const wildcard = [];
+    for (const imp of input.imports) {
+        if (imp.endsWith('.*'))
+            wildcard.push(imp.slice(0, -2));
+        else {
+            const dot = imp.lastIndexOf('.');
+            explicitImports.set(imp.slice(dot + 1), dot > 0 ? imp.slice(0, dot) : '');
+        }
+    }
+    /** Package for a short class name, or undefined when unknown. */
+    const packageOf = (short) => {
+        const imp = explicitImports.get(short);
+        if (imp !== undefined)
+            return imp;
+        const defined = definedClasses.get(short);
+        if (defined?.has(pkg))
+            return pkg;
+        if (codegen_js_1.TOPLEVEL_NAMES.has(short))
+            return '';
+        const candidates = new Set([...(defined ?? []), ...(known.get(short) ?? [])]);
+        for (const w of wildcard)
+            if (candidates.has(w))
+                return w;
+        if (candidates.has(''))
+            return '';
+        if (candidates.size === 1)
+            return [...candidates][0];
+        return undefined;
+    };
+    const resolveType = (t) => {
+        if (t.name === '*')
+            return 0;
+        if (t.params) {
+            const base = resolveType({ name: t.name === 'Vector' ? '__AS3__.vec.Vector' : t.name, pos: t.pos });
+            return pool.multiname({ kind: constants_js_1.MultinameKind.TypeName, base, params: t.params.map(resolveType) });
+        }
+        const dot = t.name.lastIndexOf('.');
+        if (dot > 0)
+            return pool.qname(pkgNs(t.name.slice(0, dot)), t.name.slice(dot + 1));
+        const p = t.name === 'Vector' ? '__AS3__.vec' : packageOf(t.name);
+        if (p !== undefined)
+            return pool.qname(pkgNs(p), t.name);
+        return pool.multiname({ kind: constants_js_1.MultinameKind.Multiname, name: pool.string(t.name), nsSet: openNsSet });
+    };
+    const resolveName = (name) => {
+        if (input.memberNames.has(name))
+            return undefined;
+        if (name === 'Vector')
+            return pool.qname(pkgNs('__AS3__.vec'), 'Vector');
+        if (explicitImports.has(name))
+            return pool.qname(pkgNs(explicitImports.get(name)), name);
+        if (!/^[A-Z]/.test(name) && !codegen_js_1.TOPLEVEL_NAMES.has(name))
+            return undefined;
+        const p = explicitImports.get(name) ?? (definedClasses.get(name)?.has(pkg) ? pkg : undefined) ?? (codegen_js_1.TOPLEVEL_NAMES.has(name) ? '' : undefined);
+        return p === undefined ? undefined : pool.qname(pkgNs(p), name);
+    };
+    const namespaceByName = (name) => {
+        switch (name) {
+            case 'private':
+                return privateNs;
+            case 'protected':
+                return protectedNs;
+            case 'static protected':
+                return staticProtectedNs ?? protectedNs;
+            case 'public':
+                return pkgNs('');
+            case 'internal':
+                return pool.namespace(constants_js_1.NamespaceKind.PackageInternalNs, pkg);
+            case 'AS3':
+                return pool.namespace(constants_js_1.NamespaceKind.Namespace, AS3_NS);
+            default:
+                return custom.get(name);
+        }
+    };
+    return { abc, pool, pkg, openNsSet, namespaceByName, resolveType, resolveName, source: input.source };
+}
+/** Namespace for a member declared with the given access keyword. */
+function memberNamespace(scope, access) {
+    if (access.startsWith('ns:')) {
+        const n = scope.namespaceByName(access.slice(3));
+        if (n === undefined)
+            throw new Error(`Unknown namespace '${access.slice(3)}'`);
+        return n;
+    }
+    return scope.namespaceByName(access === 'internal' ? 'internal' : access);
+}

package/dist/cjs/compression/lzma.d.ts

@@ -0,0 +1,37 @@
+export interface LzmaProperties {
+    lc: number;
+    lp: number;
+    pb: number;
+    dictSize: number;
+}
+export declare function parseLzmaProperties(props: Uint8Array): LzmaProperties;
+export declare function encodeLzmaProperties(p: LzmaProperties): Uint8Array;
+/**
+ * Decompress raw LZMA data.
+ * @param props 5-byte LZMA properties
+ * @param data compressed stream (without properties)
+ * @param outSize exact uncompressed size
+ */
+export declare function lzmaDecompress(props: Uint8Array, data: Uint8Array, outSize: number): Uint8Array;
+export interface LzmaCompressOptions {
+    /** Literal context bits (0-8). Default 3. */
+    lc?: number;
+    /** Literal position bits (0-4). Default 0. */
+    lp?: number;
+    /** Position bits (0-4). Default 2. */
+    pb?: number;
+    /** Dictionary size in bytes. Defaults to the input size rounded up to a power of two (max 64 MiB). */
+    dictSize?: number;
+    /** Maximum hash-chain depth for the match finder. Higher = better ratio, slower. Default 48. */
+    depth?: number;
+    /** Stop searching once a match of this length is found. Default 128. */
+    niceLength?: number;
+}
+/**
+ * Compress data with LZMA. Returns the 5-byte properties and the raw stream
+ * (no end marker, no size header), as stored in ZWS SWF files.
+ */
+export declare function lzmaCompress(input: Uint8Array, options?: LzmaCompressOptions): {
+    props: Uint8Array;
+    data: Uint8Array;
+};