@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/playerglobal/toplevel.js

@@ -0,0 +1,122 @@
+/** "pkg.Name" or "pkg::Name" as "pkg::Name", as getDefinitionByName takes either. */
+function qualify(name) {
+    if (name.includes("::")) {
+        return name;
+    }
+    const i = name.lastIndexOf(".");
+    return i < 0 ? name : `${name.slice(0, i)}::${name.slice(i + 1)}`;
+}
+/**
+ * What `name` names in `domain`, as getDefinitionByName and
+ * ApplicationDomain's lookups take a name: "pkg.Name" or "pkg::Name", or a
+ * Vector, "Vector.<T>" with or without its package, T named either way or
+ * a Vector too; `find` looks a plain name up. As Flash's, T is looked up
+ * as any definition, * among those not defined (#1065), and one that is
+ * not a class makes the Vector corrupt: what `notAClass` gives, by default
+ * VerifyError #1107, which hasDefinition counts as defined instead.
+ */
+export function definitionNamed(rt, name, find, notAClass = () => {
+    throw rt.error("VerifyError", 1107);
+}) {
+    const vector = /^(?:__AS3__\.vec(?:::|\.))?Vector\.<(.+)>$/.exec(name);
+    if (vector) {
+        const param = definitionNamed(rt, vector[1], find, notAClass);
+        return param?.$it ? rt.applyType(rt.classNamed("__AS3__.vec::Vector"), [param]) : notAClass();
+    }
+    return find(qualify(name));
+}
+const UTF8 = new TextEncoder();
+export function toplevelNatives(s) {
+    return {
+        trace: (rt) => (...args) => {
+            rt.print(args.map((v) => rt.toString(v)).join(" "));
+        },
+        // Looked up in the domain of the code that asks, as Flash's.
+        "flash.utils::getDefinitionByName": (rt) => (name) => definitionNamed(rt, rt.toString(name), (q) => rt.definitionNamed(q, s.code.codeDomain())),
+        // The alias registerClassAlias gave the value's class, which describeType writes; null for none.
+        "flash.utils::getAliasName": (rt) => (v) => {
+            if (v === null || v === undefined) {
+                return null;
+            }
+            const alias = rt.aliasOf(v.$it ? v.$it : rt.traitsOf(v));
+            return alias === "" ? null : alias;
+        },
+        // Milliseconds since the start, by the host's real clock or the frame clock (Timers.timer).
+        "flash.utils::getTimer": () => () => s.timers.timer(),
+        "flash.utils::escapeMultiByte": (rt) => (text) => escapeMultiByte(rt.toString(text)),
+        "flash.utils::unescapeMultiByte": (rt) => (text) => unescapeMultiByte(rt.toString(text)),
+    };
+}
+/** Every byte of the UTF-8 but the alphanumerics as %XX, up to a NUL; a lone surrogate is U+FFFD, as the encoder has it. */
+function escapeMultiByte(text) {
+    const nul = text.indexOf("\0");
+    const bytes = UTF8.encode(nul < 0 ? text : text.slice(0, nul));
+    let out = "";
+    for (let i = 0; i < bytes.length; i++) {
+        const b = bytes[i];
+        const alphanumeric = (b >= 0x30 && b <= 0x39) || (b >= 0x41 && b <= 0x5a) || (b >= 0x61 && b <= 0x7a);
+        out += alphanumeric
+            ? String.fromCharCode(b)
+            : `%${b.toString(16).toUpperCase().padStart(2, "0")}`;
+    }
+    return out;
+}
+const HEX = /^[0-9a-fA-F]$/;
+/**
+ * The bytes of %XX escapes and the rest as given, up to a NUL not behind a
+ * %, decoded as UTF-8 the lenient way: a % takes the next character, and
+ * one more if the first is a hex digit, and gives a byte only when both
+ * are; an encoded surrogate stands; an incomplete or invalid sequence
+ * leaves its bytes as characters of their own.
+ */
+function unescapeMultiByte(text) {
+    const bytes = [];
+    for (let i = 0; i < text.length;) {
+        const c = text[i++];
+        if (c === "\0") {
+            break;
+        }
+        if (c !== "%") {
+            for (const b of UTF8.encode(c)) {
+                bytes.push(b);
+            }
+            continue;
+        }
+        const first = text[i++];
+        if (first === undefined || !HEX.test(first)) {
+            continue;
+        }
+        const second = text[i++];
+        if (second !== undefined && HEX.test(second)) {
+            bytes.push(Number.parseInt(first + second, 16));
+        }
+    }
+    let out = "";
+    for (let i = 0; i < bytes.length;) {
+        const b = bytes[i];
+        const length = b < 0x80
+            ? 1
+            : b >= 0xc0 && b < 0xe0
+                ? 2
+                : b >= 0xe0 && b < 0xf0
+                    ? 3
+                    : b >= 0xf0 && b < 0xf8
+                        ? 4
+                        : 0;
+        let code = length === 1 ? b : length === 2 ? b & 0x1f : length === 3 ? b & 0x0f : b & 0x07;
+        let ok = length > 0 && i + length <= bytes.length;
+        for (let k = 1; ok && k < length; k++) {
+            const next = bytes[i + k];
+            ok = (next & 0xc0) === 0x80;
+            code = (code << 6) | (next & 0x3f);
+        }
+        if (!ok) {
+            out += String.fromCharCode(b);
+            i++;
+            continue;
+        }
+        out += String.fromCodePoint(code);
+        i += length;
+    }
+    return out;
+}

package/dist/thread/player/scripting/clipboard.js

@@ -0,0 +1,146 @@
+/** ClipboardFormats.TEXT_FORMAT and HTML_FORMAT, the formats a browser's clipboard carries too. */
+export const TEXT = "air:text";
+export const HTML = "air:html";
+export class Clipboard {
+    host;
+    /**
+     * What it holds, by native name: "air:text", "air:html", "air:rtf" and
+     * "air:url", and a script's own formats as "air:reference:" and
+     * "air:serialization:" and the name.
+     */
+    contents = new Map();
+    /**
+     * Clipboard.setDataHandler's handlers, by native name, each run once
+     * when its format is first read, and storing its data as it runs.
+     */
+    handlers = new Map();
+    /** A handler storing its data, which leaves the other handlers be. */
+    storing = false;
+    /** Moves with every write, so a gesture or a copy can tell whether a script wrote. */
+    version = 0;
+    gestures = 0;
+    pastes = 0;
+    /** Inside a copy or cut whose event carries the data to the system, which then needs no write of its own. */
+    collecting = 0;
+    constructor(host) {
+        this.host = host;
+    }
+    /** Whether a script may write now: while a user's event is handled. */
+    get writable() {
+        return this.gestures > 0;
+    }
+    /** Whether a script may read now: while a paste is handled. */
+    get readable() {
+        return this.pastes > 0;
+    }
+    /** The text, and HTML if any, that goes to the system's clipboard. */
+    get data() {
+        const text = this.get(TEXT);
+        const html = this.get(HTML);
+        return {
+            text: typeof text === "string" ? text : "",
+            ...(typeof html === "string" ? { html } : {}),
+        };
+    }
+    /** The formats it holds, by native name, those a handler will give too. */
+    get formats() {
+        return [...new Set([...this.contents.keys(), ...this.handlers.keys()])];
+    }
+    /** What `format` holds, after its handler, if any, has run. */
+    get(format) {
+        const handler = this.handlers.get(format);
+        if (handler) {
+            this.handlers.delete(format);
+            handler();
+        }
+        return this.contents.get(format);
+    }
+    set(format, value) {
+        if (!this.storing) {
+            this.handlers.delete(format);
+        }
+        this.contents.set(format, value);
+        this.version++;
+    }
+    /** `handler` to give `format`'s data when it is first read, in place of what it holds. */
+    setHandler(format, handler) {
+        this.contents.delete(format);
+        this.handlers.set(format, handler);
+        this.version++;
+    }
+    delete(format) {
+        this.contents.delete(format);
+        this.handlers.delete(format);
+        this.version++;
+    }
+    clear() {
+        this.contents.clear();
+        this.handlers.clear();
+        this.version++;
+    }
+    /**
+     * `f` as the handling of a user's event, in which scripts may write;
+     * once the outermost ends, what they wrote goes to the host, unless a
+     * copy event takes it.
+     */
+    gesture(f) {
+        const start = this.version;
+        this.gestures++;
+        try {
+            return f();
+        }
+        finally {
+            this.gestures--;
+            if (this.gestures === 0 && this.collecting === 0 && this.version !== start) {
+                // A host that throws must not take the key or press's handling with it.
+                try {
+                    this.host?.write(this.data);
+                }
+                catch {
+                    // The system's clipboard keeps what it had.
+                }
+            }
+        }
+    }
+    /** `f` as a copy or cut: what it wrote, for the host's event to carry, or null where it wrote nothing. */
+    collect(f) {
+        const start = this.version;
+        this.collecting++;
+        try {
+            this.gesture(f);
+        }
+        finally {
+            this.collecting--;
+        }
+        return this.version !== start ? this.data : null;
+    }
+    /**
+     * `f` as a paste of `data` from the system, in which scripts may read
+     * it. The clipboard's own formats stay where the system's text is what
+     * the SWF last put there, as a copy within the SWF comes back.
+     */
+    paste(data, f) {
+        if (data) {
+            this.receive(data);
+        }
+        this.pastes++;
+        try {
+            return this.gesture(f);
+        }
+        finally {
+            this.pastes--;
+        }
+    }
+    receive({ text, html }) {
+        const held = this.data;
+        if (held.text === text && (html === undefined || held.html === html)) {
+            return;
+        }
+        this.contents.clear();
+        this.handlers.clear();
+        this.contents.set(TEXT, text);
+        if (html !== undefined) {
+            this.contents.set(HTML, html);
+        }
+    }
+}