@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/runtime/avm2/traits.js

@@ -0,0 +1,509 @@
+// The layout model: an object's traits, its bindings and slots as the
+// module's descriptor gives them, and the references by which a module
+// names a class or a Vector type before it exists.
+import { DynamicProperties } from "./dynamic-properties.js";
+import { invalidate } from "./property-cache.js";
+// Binding kinds, as the compiler encodes them: kind | id << 3.
+export const BIND_Method = 1;
+export const BIND_Var = 2;
+export const BIND_Const = 3;
+export const BIND_Get = 5;
+export const BIND_Set = 6;
+export const BIND_GetSet = 7;
+/**
+ * Set class `cls`'s own static variable `name`, in whatever namespace, to
+ * `value`: for a class hook setting what the VM keeps there, as a private
+ * static the class reads.
+ */
+export function setStaticVar(cls, name, value) {
+    for (const [, , n, b] of cls.$desc.static.bindings) {
+        if (n === name && (b & 7) === BIND_Var) {
+            cls[`$${b >> 3}`] = value;
+        }
+    }
+}
+/**
+ * The field that holds class `cls`'s own instance variable `name`, in
+ * whatever namespace, or null if it declares none: for a player that reads
+ * or writes a private field its playerglobal's AS3 keeps.
+ */
+export function instanceVarField(cls, name) {
+    // A class no module describes, as a host's stand-in, declares none.
+    const desc = cls?.$desc;
+    for (const [, , n, b] of desc?.instance.bindings ?? []) {
+        if (n === name && (b & 7) === BIND_Var) {
+            return `$${b >> 3}`;
+        }
+    }
+    return null;
+}
+/** The builtins besides Object whose type tests isInstanceOf answers from the value, not its traits. */
+export const VALUE_TESTS = new Set(["float", "Number", "int", "uint", "String", "Boolean"]);
+/** Trait kinds as the ABC has them, which the descriptors' metadata is keyed by. */
+const TRAIT_Slot = 0;
+const TRAIT_Getter = 2;
+const TRAIT_Setter = 3;
+const TRAIT_Class = 4;
+const TRAIT_Const = 6;
+/**
+ * The traits of an object: its own bindings by local name, and its own
+ * slots' types and initial values; lookups continue in the base's, as
+ * avmplus' do, so a base described after its subclass was made (Object,
+ * Class and Function, during the bootstrap) is still seen.
+ */
+export class Traits {
+    name;
+    base;
+    bindings = new Map();
+    slotTypes = [];
+    own = [];
+    /** Every slot field and its initial value, the base's first, once an instance is made. */
+    allDefaults = null;
+    /** What the module compiled to set the slots by name, if it did (TraitsDesc.fill). */
+    fill = null;
+    /** Once an instance is made: the fill these traits' objects use, if any, and its values by slot. */
+    filler = null;
+    slotValues = [];
+    /** The JavaScript prototype of objects with these traits. */
+    proto;
+    /** The object its methods go into now (methodHome): its prototype, or one chained below it. */
+    home = null;
+    /** How many properties `home` has taken, a few counted in advance for the prototype's own. */
+    homeSize = HOME_SLACK;
+    /** Whether it declares a slot its objects keep in their array `$S` (SPILL_SLOTS). */
+    spills = false;
+    /** The class whose instances these are the traits of, once it exists. */
+    cls = null;
+    interfaces = new Set();
+    dynamic = false;
+    /** Whether it is a script's global object's, as System.isGlobal asks. */
+    isGlobal = false;
+    /**
+     * Whether a dynamic class's instances refuse any name but their own and
+     * an index, getting it or setting it, as a Vector's do: they delete one,
+     * or have one in, as any dynamic object, which it never has.
+     */
+    refusesNames = false;
+    /** How to allocate an instance, for classes whose instances hold native state. */
+    create;
+    /** The class's own hook, a builtin's or a player's; not inherited, but a specialized Vector has its base's. */
+    hooks = null;
+    /** How its instances resolve the names it does not bind, if not as dynamic properties. */
+    properties = null;
+    /** Its own slots with [Transient] metadata, if any. */
+    transientSlots = null;
+    /** Its own accessors with metadata, if any, by dispatch id: whether any of it is [Transient]. */
+    accessorMetadata = null;
+    /** Its own methods' signatures, by dispatch id, for describeType. */
+    signatures = new Map();
+    /** Its own slots' and methods' metadata, by slot id and by dispatch id, for describeType. */
+    slotMetadata = null;
+    methodMetadata = null;
+    /** The class's: whether it is final or an interface, its constructor's parameters, its own metadata. */
+    final = false;
+    isInterface = false;
+    /** The ABC that defines the class, whether it is restricted, and whether that makes it one nothing constructs. */
+    abc = null;
+    restricted = false;
+    uninstantiable = false;
+    ctor = null;
+    metadata = null;
+    getIndex;
+    setIndex;
+    hasIndex;
+    index;
+    /**
+     * Whether a type test against these traits looks at more than an object's
+     * traits, as one against Object, a number type, String or Boolean does,
+     * which takes primitives: those builtins' own, not a class named as one.
+     */
+    testsValues = false;
+    /**
+     * Object.prototype.toString's "[object Name]" for its instances, once
+     * made: the same string each time, whose hash V8 keeps, so that looking
+     * it up, as `in` a Dictionary does for each object key it misses, does
+     * not hash it anew.
+     */
+    objectString = null;
+    /**
+     * The keys of the methods its instances are called by through each
+     * interface, as Runtime.interfaceKey finds them: by the interface's
+     * traits, an array by the interface's dispatch ids. The last interface
+     * looked up, and its keys, are kept apart, as most receivers are called
+     * through one.
+     */
+    interfaceKeys = null;
+    lastInterface = null;
+    lastInterfaceKeys = [];
+    constructor(name, base, proto) {
+        this.name = name;
+        this.base = base;
+        this.proto = proto ?? Object.create(base ? base.proto : null);
+        this.proto.$traits = this;
+        this.create = base ? base.create : null;
+        this.properties = base ? base.properties : null;
+        this.getIndex = base?.getIndex;
+        this.setIndex = base?.setIndex;
+        this.hasIndex = base?.hasIndex;
+        this.index = base?.index;
+        if (base) {
+            for (const i of base.interfaces) {
+                this.interfaces.add(i);
+            }
+        }
+    }
+    /**
+     * The object a method and its entries, `count` properties, go into:
+     * the prototype, till it holds HOME_PROPERTIES, then an object chained
+     * below it, above the base's, and so on. V8 keeps an object of more
+     * than 1020 properties as a dictionary, which hashes every name looked
+     * up in it: a script of thousands of functions, as Crossbridge compiles
+     * C, called each through such a prototype ran five times as slow as
+     * through one that is not. A prototype chain of objects V8 keeps fast
+     * looks a name up as fast as one object.
+     */
+    methodHome(count) {
+        let home = this.home ?? this.proto;
+        if (this.homeSize + count > HOME_PROPERTIES) {
+            // Chained before it takes its methods: V8 keeps an object fast that is a prototype first.
+            const below = Object.create(Object.getPrototypeOf(home));
+            Object.setPrototypeOf(home, below);
+            home = below;
+            this.homeSize = 0;
+        }
+        this.home = home;
+        this.homeSize += count;
+        return home;
+    }
+    /** Add a traits' own bindings and slots from its descriptor. */
+    describe(desc) {
+        invalidate();
+        for (const [ns, version, name, value] of desc.bindings) {
+            let list = this.bindings.get(name);
+            if (!list) {
+                list = [];
+                this.bindings.set(name, list);
+            }
+            list.push({ ns, version, value });
+        }
+        for (const [slot, value, type] of desc.defaults) {
+            this.slotTypes[slot] = type;
+            this.own.push([slotKey(slot), value]);
+            if (slot >= SPILL_SLOTS) {
+                this.spills = true;
+                spilledSlot(this.methodHome(1), slot);
+            }
+        }
+        for (const [d, , , returnType, params, required] of desc.methods) {
+            this.signatures.set(d, [returnType, params, required]);
+        }
+        if (desc.meta) {
+            this.annotate(desc.meta);
+        }
+        this.fill = desc.fill ?? null;
+        this.allDefaults = null;
+    }
+    /**
+     * Keep the traits' metadata, and what AMF and JSON ask of it: the slots
+     * with [Transient], and for each accessor with metadata whether any of
+     * it is [Transient], since an accessor's metadata hides its base's, as
+     * avmplus' getMethodMetadataPos finds it.
+     */
+    annotate(meta) {
+        const transient = (entries) => entries.some(([name]) => name === "Transient");
+        for (const [kind, id, entries] of meta) {
+            if (kind === TRAIT_Slot || kind === TRAIT_Const || kind === TRAIT_Class) {
+                this.slotMetadata ??= new Map();
+                this.slotMetadata.set(id, entries);
+                if (transient(entries)) {
+                    this.transientSlots ??= new Set();
+                    this.transientSlots.add(id);
+                }
+            }
+            else {
+                this.methodMetadata ??= new Map();
+                this.methodMetadata.set(id, entries);
+                if (kind === TRAIT_Getter || kind === TRAIT_Setter) {
+                    this.accessorMetadata ??= new Map();
+                    this.accessorMetadata.set(id, transient(entries));
+                }
+            }
+        }
+    }
+    /**
+     * Whether the member binding `b` names is [Transient], which AMF and
+     * JSON leave out: a slot, or either accessor of a pair, whose metadata,
+     * found as avmplus' TraitsMetadata finds it, has it.
+     */
+    isTransient(b) {
+        const kind = b & 7;
+        const id = b >> 3;
+        if (kind === BIND_Var || kind === BIND_Const) {
+            for (let t = this; t; t = t.base) {
+                if (t.transientSlots?.has(id)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        return (((kind === BIND_Get || kind === BIND_GetSet) && this.transientAccessor(id)) ||
+            ((kind === BIND_Set || kind === BIND_GetSet) && this.transientAccessor(id + 1)));
+    }
+    /** Whether accessor `id`'s metadata, the nearest traits' that has any, is [Transient]. */
+    transientAccessor(id) {
+        for (let t = this; t; t = t.base) {
+            const transient = t.accessorMetadata?.get(id);
+            if (transient !== undefined) {
+                return transient;
+            }
+        }
+        return false;
+    }
+    /** Whether it or a base declares a slot kept in the array `$S`. */
+    spillsAny() {
+        for (let t = this; t; t = t.base) {
+            if (t.spills) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** The type of slot `id`, declared here or by a base. */
+    slotType(id) {
+        for (let t = this; t; t = t.base) {
+            if (id in t.slotTypes) {
+                return t.slotTypes[id];
+            }
+        }
+        return null;
+    }
+    /** The binding `mn` names, or 0: the first of its namespaces that binds it at its version. */
+    find(mn) {
+        const name = mn.name;
+        if (name === null) {
+            return 0;
+        }
+        const namespaces = mn.namespaces;
+        for (let t = this; t; t = t.base) {
+            const list = t.bindings.get(name);
+            if (!list) {
+                continue;
+            }
+            // Indexes, not for-of: compiled code looks its names up here.
+            for (let i = 0; i < namespaces.length; i++) {
+                const ns = namespaces[i];
+                for (let k = 0; k < list.length; k++) {
+                    const b = list[k];
+                    if (b.ns === ns && b.version <= mn.versions[i]) {
+                        return b.value;
+                    }
+                }
+            }
+        }
+        return 0;
+    }
+    /** A new object with these traits, its slots at their initial values. */
+    instance() {
+        const o = this.create ? this.create(this) : Object.create(this.proto);
+        o.$d = this.dynamic ? new DynamicProperties() : null;
+        if (!this.allDefaults) {
+            this.allDefaults = this.base ? [...this.base.defaultsOf(), ...this.own] : this.own.slice();
+            this.filler = this.fillOf();
+            this.slotValues = this.filler ? valuesBySlot(this.allDefaults) : [];
+        }
+        if (this.filler) {
+            this.filler(o, this.slotValues);
+        }
+        else {
+            // Those past SPILL_SLOTS through their accessors, into the array.
+            if (this.spillsAny()) {
+                o.$S = [];
+            }
+            // Traits no module compiled a fill for: a catch scope's, or past
+            // FILL_SLOTS, where V8 keeps no object fast anyway.
+            const defaults = this.allDefaults;
+            for (let i = 0; i < defaults.length; i++) {
+                o[defaults[i][0]] = defaults[i][1];
+            }
+        }
+        return o;
+    }
+    /** The fill for these traits' objects: their module's, or a base's that has all their slots, as a Vector.<T>'s. */
+    fillOf() {
+        if (this.fill || this.own.length) {
+            return this.fill;
+        }
+        return this.base ? this.base.fillOf() : null;
+    }
+    defaultsOf() {
+        return this.allDefaults ?? (this.base ? [...this.base.defaultsOf(), ...this.own] : this.own);
+    }
+    /**
+     * Interfaces named by a class made before them, as a script may define a
+     * class before an interface it implements: each gives the interface's
+     * traits once its class exists, or null before. avmplus takes interfaces
+     * from traits, which exist from loading; these are settled when a type
+     * test first needs them.
+     */
+    pendingInterfaces = null;
+    /** Add the interfaces now made that were pending, here and in the bases. */
+    settleInterfaces() {
+        for (let c = this; c; c = c.base) {
+            const pending = c.pendingInterfaces;
+            if (!pending) {
+                continue;
+            }
+            c.pendingInterfaces = pending.filter((get) => {
+                const iface = get();
+                if (!iface) {
+                    return true;
+                }
+                iface.settleInterfaces();
+                c.interfaces.add(iface);
+                for (const i of iface.interfaces) {
+                    c.interfaces.add(i);
+                }
+                return false;
+            });
+            if (!c.pendingInterfaces.length) {
+                c.pendingInterfaces = null;
+            }
+        }
+    }
+    /**
+     * The interfaces of this class and its bases, once none of them has one
+     * pending: from then on what isSubtypeOf answers no more changes, and
+     * a class that is not t answers by this alone, as `is` on a 3D
+     * engine's scene nodes asks every frame.
+     */
+    allInterfaces = null;
+    isSubtypeOf(t) {
+        for (let c = this; c; c = c.base) {
+            if (c === t) {
+                return true;
+            }
+        }
+        // A class is a supertype only as a base; only interfaces are in the sets below.
+        if (!t.isInterface) {
+            return false;
+        }
+        if (this.allInterfaces !== null) {
+            return this.allInterfaces.has(t);
+        }
+        if (this.interfaces.has(t)) {
+            return true;
+        }
+        // An interface a base settled after this class copied its interfaces.
+        this.settleInterfaces();
+        let settled = true;
+        const all = new Set();
+        for (let c = this; c; c = c.base) {
+            if (c.pendingInterfaces) {
+                settled = false;
+            }
+            for (const i of c.interfaces) {
+                all.add(i);
+            }
+        }
+        if (settled) {
+            this.allInterfaces = all;
+        }
+        return all.has(t);
+    }
+}
+/** A class named in a module, resolved the first time it is needed. */
+export class ClassRef {
+    ns;
+    name;
+    domain;
+    cls = null;
+    /**
+     * Its instances' traits, once coerceTo has found them; a compiled
+     * method's parameter of the type reads them by name on entry.
+     */
+    traits = null;
+    constructor(ns, name, 
+    /** The domain its module was loaded into, which it is resolved in. */
+    domain) {
+        this.ns = ns;
+        this.name = name;
+        this.domain = domain;
+    }
+}
+/** Vector.<T>, resolved the first time it is needed. */
+export class VectorRef {
+    param;
+    cls = null;
+    /**
+     * Its instances' traits, once coerceTo has found them; a compiled
+     * method's parameter of the type reads them by name on entry.
+     */
+    traits = null;
+    constructor(param) {
+        this.param = param;
+    }
+}
+/** The initial values of `defaults` by slot id, the last of a slot listed twice, as they are set. */
+function valuesBySlot(defaults) {
+    let count = 0;
+    for (const [key] of defaults) {
+        count = Math.max(count, Number(key.slice(1)) + 1);
+    }
+    const values = new Array(count).fill(undefined);
+    for (const [key, value] of defaults) {
+        values[Number(key.slice(1))] = value;
+    }
+    return values;
+}
+/**
+ * The properties a prototype object takes before its traits' methods go
+ * on in another below it (Traits.methodHome), well short of V8's 1020; a
+ * few counted in advance for the prototype's own ($traits, $p, $init).
+ */
+const HOME_PROPERTIES = 768;
+const HOME_SLACK = 16;
+/**
+ * The first slot an object keeps in its array `$S` rather than in a
+ * property of its own, as the codegen's SPILL_SLOTS (emit/refs.ts), which
+ * compiled code reads and writes there (`o.$S[n - SPILL_SLOTS]`): V8
+ * keeps an object of more than 1020 properties as a dictionary, which
+ * hashes every name looked up in it. A Crossbridge program's global, of
+ * thousands of slots, its stack pointer and registers among the first,
+ * ran five times as slow as one that is not. The slot's name reaches the
+ * array through an accessor on the prototype (spilledSlot), so that what
+ * looks slots up by name finds them as any other.
+ */
+export const SPILL_SLOTS = 900;
+/** Slot `slot`'s accessor in `home`, a prototype of its objects: the object's `$S` at its place. */
+function spilledSlot(home, slot) {
+    const at = slot - SPILL_SLOTS;
+    Object.defineProperty(home, slotKey(slot), {
+        get() {
+            return this.$S[at];
+        },
+        set(v) {
+            this.$S[at] = v;
+        },
+        configurable: true,
+    });
+}
+// The names of slot and method properties by id, made once each, for the
+// runtime's dynamic paths; generated code names them itself.
+const slotKeys = [];
+const methodKeys = [];
+export const slotKey = (id) => (slotKeys[id] ??= `$${id}`);
+export const methodKey = (id) => (methodKeys[id] ??= `$m${id}`);
+const untypedSetKeys = [];
+/**
+ * Where a native's setter, dispatch id `id`, is kept as an untyped set
+ * calls it, its value coerced (installMethod); a setter with none is
+ * called as it is.
+ */
+export const untypedSetKey = (id) => (untypedSetKeys[id] ??= `$u${id}`);
+const boundKeys = [];
+/**
+ * Where a method, dispatch id `id`, is kept as calls the compiler bound
+ * call it, their arguments coerced and counted already: its entry for
+ * them if it has one (a compiled method's `$bound`), else itself.
+ */
+export const boundKey = (id) => (boundKeys[id] ??= `$b${id}`);

package/dist/thread/runtime/index.js

@@ -0,0 +1,7 @@
+/**
+ * Language runtime that generated code calls into. Only AS2/AS3 semantics
+ * live here; playerglobal belongs to @swf2es/player, so this package runs in
+ * node next to avmshell for conformance tests.
+ */
+export * as avm1 from "./avm1/index.js";
+export * as avm2 from "./avm2/index.js";

package/dist/web-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=web-worker.d.ts.map

package/dist/web-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-worker.d.ts","sourceRoot":"","sources":["../src/web-worker.ts"],"names":[],"mappings":""}

package/dist/web-worker.js

@@ -0,0 +1,20 @@
+// A Web Worker running one background flash.system.Worker (workers.ts).
+import { runWorkerThread } from "@swf2es/player/worker";
+// The DOM's types, not a worker's, are this package's: its global scope as a worker sees it.
+const scope = globalThis;
+runWorkerThread({
+    post: (message) => scope.postMessage(message),
+    listen: (receive) => {
+        scope.onmessage = (event) => {
+            // The host's first message: answered, it tells the host that what it
+            // posts reaches this worker, which it then counts on while the page's
+            // thread is blocked (workers.ts).
+            if (event.data?.type === "ping") {
+                scope.postMessage({ type: "ready" });
+                return;
+            }
+            receive(event.data);
+        };
+    },
+});
+//# sourceMappingURL=web-worker.js.map

package/dist/web-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-worker.js","sourceRoot":"","sources":["../src/web-worker.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,6FAA6F;AAC7F,MAAM,KAAK,GAAG,UAGb,CAAC;AACF,eAAe,CAAC;IACd,IAAI,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,WAAW,CAAC,OAAO,CAAC;IAC7C,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE;QAClB,KAAK,CAAC,SAAS,GAAG,CAAC,KAAK,EAAE,EAAE;YAC1B,qEAAqE;YACrE,sEAAsE;YACtE,kCAAkC;YAClC,IAAI,KAAK,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,EAAE,CAAC;gBAChC,KAAK,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;gBACrC,OAAO;YACT,CAAC;YAED,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACtB,CAAC,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

package/dist/websocket.d.ts

@@ -0,0 +1,4 @@
+import type { SocketHost } from "@swf2es/player";
+/** Map the AS3 host and port to a WebSocket endpoint that relays a byte stream. */
+export declare function webSocketSocketHost(urlFor: (host: string, port: number) => string, open?: (url: string) => WebSocket): SocketHost;
+//# sourceMappingURL=websocket.d.ts.map

package/dist/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../src/websocket.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,mFAAmF;AACnF,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,EAC9C,IAAI,GAAE,CAAC,GAAG,EAAE,MAAM,KAAK,SAAuC,GAC7D,UAAU,CAwBZ"}

package/dist/websocket.js

@@ -0,0 +1,27 @@
+/** Map the AS3 host and port to a WebSocket endpoint that relays a byte stream. */
+export function webSocketSocketHost(urlFor, open = (url) => new WebSocket(url)) {
+    return {
+        connect(host, port, events) {
+            const socket = open(urlFor(host, port));
+            socket.binaryType = "arraybuffer";
+            socket.addEventListener("open", () => events.open());
+            socket.addEventListener("message", ({ data }) => {
+                if (data instanceof ArrayBuffer) {
+                    events.data(new Uint8Array(data));
+                }
+                else {
+                    events.error("Socket bridge sent a non-binary WebSocket message.");
+                    socket.close();
+                }
+            });
+            socket.addEventListener("close", () => events.close());
+            socket.addEventListener("error", () => events.error("Error #2031: Socket Error."));
+            return {
+                // Browser WebSocket accepts typed arrays; the Socket native supplies ArrayBuffer-backed bytes.
+                send: (bytes) => socket.send(bytes),
+                close: () => socket.close(),
+            };
+        },
+    };
+}
+//# sourceMappingURL=websocket.js.map

package/dist/websocket.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.js","sourceRoot":"","sources":["../src/websocket.ts"],"names":[],"mappings":"AAGA,mFAAmF;AACnF,MAAM,UAAU,mBAAmB,CACjC,MAA8C,EAC9C,IAAI,GAA+B,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,SAAS,CAAC,GAAG,CAAC;IAE9D,OAAO;QACL,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM;YACxB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;YACxC,MAAM,CAAC,UAAU,GAAG,aAAa,CAAC;YAClC,MAAM,CAAC,gBAAgB,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;YACrD,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;gBAC9C,IAAI,IAAI,YAAY,WAAW,EAAE,CAAC;oBAChC,MAAM,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;gBACpC,CAAC;qBAAM,CAAC;oBACN,MAAM,CAAC,KAAK,CAAC,oDAAoD,CAAC,CAAC;oBACnE,MAAM,CAAC,KAAK,EAAE,CAAC;gBACjB,CAAC;YACH,CAAC,CAAC,CAAC;YACH,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;YACvD,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC,CAAC;YAEnF,OAAO;gBACL,+FAA+F;gBAC/F,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,KAAgC,CAAC;gBAC9D,KAAK,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE;aAC5B,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/workers.d.ts

@@ -0,0 +1,35 @@
+import type { WorkerHost } from "@swf2es/player";
+export interface WebWorkerHostOptions {
+    /** codegen.wasm compiled, as the player's own codegen was made from. */
+    codegen: WebAssembly.Module;
+    /**
+     * The worker script: by default this package's dist/thread/, which
+     * holds web-worker.js and the modules it imports with their bare
+     * specifiers made relative (build-thread.ts), so that it loads wherever
+     * the package is served, as a worker sees no import map. One from
+     * another origin, as a CDN's, starts through a module of the page's own
+     * that imports it, which a Content-Security-Policy must allow as a
+     * worker's `blob:` source.
+     */
+    url?: string | URL;
+    /**
+     * How many Web Workers to keep started ahead, for workers a script starts
+     * and then waits for without returning to the event loop: by default as
+     * many as the machine has cores, from 2 up to 4. The page's hosts for one
+     * script URL share them, and they are let go a while after the last
+     * player that used them is.
+     */
+    spares?: number;
+}
+/** A host of Web Workers, and when the workers it started ahead have loaded. */
+export interface WebWorkerHost extends WorkerHost {
+    /**
+     * Resolves once the workers started ahead have loaded, or failed to:
+     * a page that awaits it before it plays a SWF has them for a script
+     * that blocks at once.
+     */
+    readonly ready: Promise<void>;
+}
+/** Background workers on module Web Workers. */
+export declare function webWorkerHost(options: WebWorkerHostOptions): WebWorkerHost;
+//# sourceMappingURL=workers.d.ts.map

package/dist/workers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workers.d.ts","sourceRoot":"","sources":["../src/workers.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGjD,MAAM,WAAW,oBAAoB;IACnC,wEAAwE;IACxE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC;IAC5B;;;;;;;;OAQG;IACH,GAAG,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;IACnB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,gFAAgF;AAChF,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AAuJD,gDAAgD;AAChD,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,aAAa,CAiD1E"}