@swf2es/player-hosts 0.1.3 → 0.1.5

package/dist/thread/runtime/avm2/natives/bytearray.js

@@ -2,13 +2,14 @@
 // DataInput/DataOutput implement them. The buffer keeps avmplus' capacity:
 // it grows as avmplus' Grower grows it, zeroing what a reallocation adds,
 // so bytes a shorter length left behind come back when the length grows
-// within the capacity, as they do in avmplus. UTF-8 is avmplus' own: an
-// invalid byte reads as the character of its value.
+// within the capacity, as they do in avmplus. UTF-8 is avmplus' own
+// (utf8.ts).
 //
-// Translated from avmplus' core/ByteArrayGlue.cpp, core/DataIO.cpp and
-// core/UnicodeUtils.cpp, this file is subject to the Mozilla Public
-// License, v. 2.0: http://mozilla.org/MPL/2.0/.
+// Translated from avmplus' core/ByteArrayGlue.cpp and core/DataIO.cpp,
+// this file is subject to the Mozilla Public License, v. 2.0:
+// http://mozilla.org/MPL/2.0/.
 import { CompressedDataError, CompressedDataTooLargeError, deflateCompress, LZMA_HEADER, lzmaByteArrayCompress, lzmaByteArrayUncompress, zlibCompress, zlibUncompress, } from "../../../format/index.js";
+import { fromCodes, fromUtf8, utf8 } from "../utf8.js";
 import { registerNativeClass } from "./define.js";
 const kGrowthIncr = 4096;
 const kHugeGrowthThreshold = 24 * 1024 * 1024;
@@ -527,167 +528,6 @@ export function sharedByteArray(rt, memory) {
 export function knownSharedByteArray(rt, id) {
     return sharedObjectsOf(rt).get(id)?.deref();
 }
-/** The host's UTF-8 encoder, which writes a lone surrogate as U+FFFD, as utf8() does. */
-const encoder = new TextEncoder();
-/**
- * Below this length, a string encodes faster here than through
- * TextEncoder, whose call costs more than the loop saves (about 90
- * characters in V8).
- */
-const ENCODER_LENGTH = 96;
-/**
- * As UnicodeUtils::Utf16ToUtf8: a surrogate pair as four bytes, a lone
- * surrogate as U+FFFD. avmshell's writeUTFBytes loses characters around a
- * lone one instead; this keeps them, and the UTF-8 valid.
- */
-export function utf8(s) {
-    if (s.length >= ENCODER_LENGTH) {
-        return encoder.encode(s);
-    }
-    // ASCII, byte for byte.
-    let ascii = true;
-    for (let i = 0; i < s.length && ascii; i++) {
-        ascii = s.charCodeAt(i) < 0x80;
-    }
-    if (ascii) {
-        const out = new Uint8Array(s.length);
-        for (let i = 0; i < s.length; i++) {
-            out[i] = s.charCodeAt(i);
-        }
-        return out;
-    }
-    const out = new Uint8Array(s.length * 3);
-    let n = 0;
-    for (let i = 0; i < s.length; i++) {
-        let ch = s.charCodeAt(i);
-        if (ch < 0x80) {
-            out[n++] = ch;
-            continue;
-        }
-        if (ch < 0x800) {
-            out[n++] = 0xc0 | ((ch >> 6) & 0x1f);
-            out[n++] = 0x80 | (ch & 0x3f);
-            continue;
-        }
-        if (ch >= 0xd800 && ch <= 0xdbff) {
-            const ch2 = i + 1 < s.length ? s.charCodeAt(i + 1) : 0;
-            if (ch2 >= 0xdc00 && ch2 <= 0xdfff) {
-                i++;
-                const ucs4 = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000;
-                out[n++] = 0xf0 | ((ucs4 >> 18) & 0x07);
-                out[n++] = 0x80 | ((ucs4 >> 12) & 0x3f);
-                out[n++] = 0x80 | ((ucs4 >> 6) & 0x3f);
-                out[n++] = 0x80 | (ucs4 & 0x3f);
-                continue;
-            }
-            ch = 0xfffd;
-        }
-        else if (ch >= 0xdc00 && ch <= 0xdfff) {
-            ch = 0xfffd;
-        }
-        out[n++] = 0xe0 | ((ch >> 12) & 0x0f);
-        out[n++] = 0x80 | ((ch >> 6) & 0x3f);
-        out[n++] = 0x80 | (ch & 0x3f);
-    }
-    return out.subarray(0, n);
-}
-/**
- * As UnicodeUtils::Utf8ToUtf16, not strict: a byte that does not start a
- * valid sequence is the character of its value, and a four-byte sequence
- * may start with 0xF8 to 0xFF, as Flash Player 9 and 10 read them.
- */
-/** The length from which fromUtf8 first looks for ASCII. */
-const ASCII_LENGTH = 16;
-export function fromUtf8(bytes) {
-    const n = bytes.length;
-    // ASCII, as most text is: its bytes are its characters. Below
-    // ASCII_LENGTH bytes, a character at a time, until one is not.
-    if (n < ASCII_LENGTH) {
-        let s = "";
-        let k = 0;
-        for (; k < n && bytes[k] < 0x80; k++) {
-            s += String.fromCharCode(bytes[k]);
-        }
-        if (k === n) {
-            return s;
-        }
-    }
-    else {
-        let ascii = 0;
-        while (ascii < n && bytes[ascii] < 0x80) {
-            ascii++;
-        }
-        if (ascii === n) {
-            let s = "";
-            for (let k = 0; k < n; k += 8192) {
-                s += String.fromCharCode.apply(null, bytes.subarray(k, k + 8192));
-            }
-            return s;
-        }
-    }
-    const out = [];
-    let i = 0;
-    while (i < n) {
-        const c = bytes[i];
-        const left = n - i;
-        switch (c >> 4) {
-            case 12:
-            case 13: {
-                if (left >= 2 && (bytes[i + 1] & 0xc0) === 0x80) {
-                    const ch = ((c << 6) & 0x7c0) | (bytes[i + 1] & 0x3f);
-                    if (ch >= 0x80) {
-                        out.push(ch);
-                        i += 2;
-                        continue;
-                    }
-                }
-                break;
-            }
-            case 14: {
-                if (left >= 3 && (bytes[i + 1] & 0xc0) === 0x80 && (bytes[i + 2] & 0xc0) === 0x80) {
-                    const ch = ((c << 12) & 0xf000) | ((bytes[i + 1] << 6) & 0xfc0) | (bytes[i + 2] & 0x3f);
-                    if (ch >= 0x800) {
-                        out.push(ch);
-                        i += 3;
-                        continue;
-                    }
-                }
-                break;
-            }
-            case 15: {
-                if (left >= 4 &&
-                    (bytes[i + 1] & 0xc0) === 0x80 &&
-                    (bytes[i + 2] & 0xc0) === 0x80 &&
-                    (bytes[i + 3] & 0xc0) === 0x80) {
-                    const ch = ((c << 18) & 0x1c0000) |
-                        ((bytes[i + 1] << 12) & 0x3f000) |
-                        ((bytes[i + 2] << 6) & 0xfc0) |
-                        (bytes[i + 3] & 0x3f);
-                    if (ch >= 0x10000) {
-                        out.push((((ch - 0x10000) >> 10) & 0x3ff) + 0xd800, ((ch - 0x10000) & 0x3ff) + 0xdc00);
-                        i += 4;
-                        continue;
-                    }
-                }
-                break;
-            }
-            default:
-                break;
-        }
-        // Not a sequence: the byte itself.
-        out.push(c);
-        i++;
-    }
-    return fromCodes(out);
-}
-/** A string of UTF-16 code units, in chunks, as String.fromCharCode takes only so many arguments. */
-function fromCodes(units) {
-    let s = "";
-    for (let k = 0; k < units.length; k += 8192) {
-        s += String.fromCharCode(...units.slice(k, k + 8192));
-    }
-    return s;
-}
 /** The bytes up to the first NUL, as avmplus reads a C string. */
 function toNul(bytes) {
     const nul = bytes.indexOf(0);

package/dist/thread/runtime/avm2/natives/regexp.js

@@ -170,25 +170,25 @@ function variableLookbehind(source) {
     /** The length of the item at i, which it steps past. */
     const item = () => {
         const c = source[i++];
-        if (c === "(") {
-            return group();
-        }
-        if (c === "^" || c === "$") {
-            return 0;
-        }
-        if (c === "[") {
-            if (source[i] === "^") {
-                i++;
-            }
-            // A ] first is a literal.
-            if (source[i] === "]") {
+        switch (c) {
+            case "(":
+                return group();
+            case "^":
+            case "$":
+                return 0;
+            case "[":
+                if (source[i] === "^") {
+                    i++;
+                }
+                // A ] first is a literal.
+                if (source[i] === "]") {
+                    i++;
+                }
+                while (i < source.length && source[i] !== "]") {
+                    i += source[i] === "\\" ? 2 : 1;
+                }
                 i++;
-            }
-            while (i < source.length && source[i] !== "]") {
-                i += source[i] === "\\" ? 2 : 1;
-            }
-            i++;
-            return 1;
+                return 1;
         }
         if (c !== "\\") {
             // A character beyond the BMP is one in PCRE's UTF-8 too.
@@ -265,57 +265,61 @@ function nestedTooDeep(source) {
     for (let i = 0; i < source.length; i++) {
         const c = source[i];
         let item = 2;
-        if (c === "(") {
-            const capture = source[i + 1] !== "?" || source.startsWith("(?P<", i);
-            outer.push(held);
-            held += previous + (capture ? 5 : 3);
-            previous = 0;
-            if (held > WORKSPACE) {
-                return true;
-            }
-            // Past the group's kind: ?: ?= ?! ?<= ?<! ?P<name> or flags.
-            if (source[i + 1] === "?") {
-                const end = source.slice(i + 2).search(/[:=!>)]/);
-                i = end < 0 ? source.length : i + 2 + end;
+        switch (c) {
+            case "(": {
+                const capture = source[i + 1] !== "?" || source.startsWith("(?P<", i);
+                outer.push(held);
+                held += previous + (capture ? 5 : 3);
+                previous = 0;
+                if (held > WORKSPACE) {
+                    return true;
+                }
+                // Past the group's kind: ?: ?= ?! ?<= ?<! ?P<name> or flags.
+                if (source[i + 1] === "?") {
+                    const end = source.slice(i + 2).search(/[:=!>)]/);
+                    i = end < 0 ? source.length : i + 2 + end;
+                }
+                continue;
             }
-            continue;
-        }
-        if (c === ")") {
-            held = outer.pop() ?? held;
-            // The group is the next one's previous item, but what it holds is gone.
-            previous = 0;
-            continue;
-        }
-        if (c === "|") {
-            previous = 0;
-            continue;
-        }
-        if (c === "\\") {
-            i++;
-        }
-        else if (c === "[") {
-            // A class is its opcode and a 32-byte bitmap.
-            item = 33;
-            i++;
-            if (source[i] === "^") {
+            case ")":
+                held = outer.pop() ?? held;
+                // The group is the next one's previous item, but what it holds is gone.
+                previous = 0;
+                continue;
+            case "|":
+                previous = 0;
+                continue;
+            case "\\":
                 i++;
-            }
-            // A ] first is a literal.
-            if (source[i] === "]") {
+                break;
+            case "[":
+                // A class is its opcode and a 32-byte bitmap.
+                item = 33;
                 i++;
-            }
-            while (i < source.length && source[i] !== "]") {
-                if (source[i] === "\\") {
+                if (source[i] === "^") {
                     i++;
                 }
-                i++;
-            }
-        }
-        else if (c === "." || c === "^" || c === "$") {
-            item = 1;
-        }
-        else if ("*+?{".includes(c)) {
-            continue;
+                // A ] first is a literal.
+                if (source[i] === "]") {
+                    i++;
+                }
+                while (i < source.length && source[i] !== "]") {
+                    if (source[i] === "\\") {
+                        i++;
+                    }
+                    i++;
+                }
+                break;
+            case ".":
+            case "^":
+            case "$":
+                item = 1;
+                break;
+            case "*":
+            case "+":
+            case "?":
+            case "{":
+                continue;
         }
         previous = item;
         if (held + previous > WORKSPACE) {

package/dist/thread/runtime/avm2/natives/shell-workers.js

@@ -8,7 +8,7 @@
 // The host starts the threads (RuntimeOptions.workers); each runs a
 // runtime made with its worker's ShellWorkerInit, which the runtime finds
 // here by its id.
-import { fromUtf8, utf8 } from "./bytearray.js";
+import { fromUtf8, utf8 } from "../utf8.js";
 import { Sync } from "./sync.js";
 /** avmplus' Isolate::State. */
 export const NEW = 1;

package/dist/thread/runtime/avm2/natives/shell.js

@@ -3,7 +3,8 @@
 // the host starts (RuntimeOptions.workers; shell-workers.ts).
 import { Reader, Writer } from "../amf.js";
 import { setStaticVar } from "../traits.js";
-import { byteArrayCapacity, bytesOf, fromUtf8, GLOBAL_MEMORY_MIN_SIZE, knownSharedByteArray, setDomainMemory, sharedByteArray, utf8, } from "./bytearray.js";
+import { fromUtf8, utf8 } from "../utf8.js";
+import { byteArrayCapacity, bytesOf, GLOBAL_MEMORY_MIN_SIZE, knownSharedByteArray, setDomainMemory, sharedByteArray, } from "./bytearray.js";
 import { syncObject, syncOf, syncRef } from "./concurrent.js";
 import { elements, registerNativeClass } from "./define.js";
 import { CANSTART, entryKey, FAILED, ITEM_AMF, ITEM_BYTES, ITEM_NUMBER, ITEM_SHARED, ITEM_SYNC, NEW, newWorkersMemory, RUNNING, STATE_NAMES, sleep, Workers, WorkerTerminated, } from "./shell-workers.js";

package/dist/thread/runtime/avm2/natives/xml/parser.js

@@ -11,8 +11,8 @@ export const TAG_TEXT = 3;
 export const TAG_CDATA = 4;
 export const TAG_PROCESSING_INSTRUCTION = 7;
 export const TAG_COMMENT = 8;
-export const TAG_DOCTYPE = 10;
-export const TAG_XML_DECLARATION = 13;
+const TAG_DOCTYPE = 10;
+const TAG_XML_DECLARATION = 13;
 // What getNext gives, as XMLParser's status codes: a tag, the end, or the
 // error E4X throws for each (see PARSE_ERRORS in values.ts).
 export const OK = 0;

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

@@ -7,7 +7,7 @@
 //
 // Translated from avmplus' core/MathUtils.cpp and core/d2a.cpp, this file is
 // subject to the Mozilla Public License, v. 2.0: http://mozilla.org/MPL/2.0/.
-export const DTOSTR_NORMAL = 0;
+const DTOSTR_NORMAL = 0;
 export const DTOSTR_FIXED = 1;
 export const DTOSTR_PRECISION = 2;
 export const DTOSTR_EXPONENTIAL = 3;

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

@@ -574,14 +574,16 @@ export class Runtime {
         if (!traits) {
             traits = this.builtinClass(name).$it;
             this.builtinTraitsByName.set(name, traits);
-            if (name === "String") {
-                this.stringTraits = traits;
-            }
-            else if (name === "Number") {
-                this.numberTraits = traits;
-            }
-            else if (name === "Boolean") {
-                this.booleanTraits = traits;
+            switch (name) {
+                case "String":
+                    this.stringTraits = traits;
+                    break;
+                case "Number":
+                    this.numberTraits = traits;
+                    break;
+                case "Boolean":
+                    this.booleanTraits = traits;
+                    break;
             }
         }
         return traits;

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

@@ -473,7 +473,7 @@ const HOME_SLACK = 16;
  * 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;
+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;

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

@@ -0,0 +1,167 @@
+// UTF-8 as avmplus reads and writes it: an invalid byte reads as the
+// character of its value, a lone surrogate writes as U+FFFD. ByteArray,
+// AMF and the shell's natives share it.
+//
+// Translated from avmplus' core/UnicodeUtils.cpp, this file is subject to
+// the Mozilla Public License, v. 2.0: http://mozilla.org/MPL/2.0/.
+/** The host's UTF-8 encoder, which writes a lone surrogate as U+FFFD, as utf8() does. */
+const encoder = new TextEncoder();
+/**
+ * Below this length, a string encodes faster here than through
+ * TextEncoder, whose call costs more than the loop saves (about 90
+ * characters in V8).
+ */
+const ENCODER_LENGTH = 96;
+/**
+ * As UnicodeUtils::Utf16ToUtf8: a surrogate pair as four bytes, a lone
+ * surrogate as U+FFFD. avmshell's writeUTFBytes loses characters around a
+ * lone one instead; this keeps them, and the UTF-8 valid.
+ */
+export function utf8(s) {
+    if (s.length >= ENCODER_LENGTH) {
+        return encoder.encode(s);
+    }
+    // ASCII, byte for byte.
+    let ascii = true;
+    for (let i = 0; i < s.length && ascii; i++) {
+        ascii = s.charCodeAt(i) < 0x80;
+    }
+    if (ascii) {
+        const out = new Uint8Array(s.length);
+        for (let i = 0; i < s.length; i++) {
+            out[i] = s.charCodeAt(i);
+        }
+        return out;
+    }
+    const out = new Uint8Array(s.length * 3);
+    let n = 0;
+    for (let i = 0; i < s.length; i++) {
+        let ch = s.charCodeAt(i);
+        if (ch < 0x80) {
+            out[n++] = ch;
+            continue;
+        }
+        if (ch < 0x800) {
+            out[n++] = 0xc0 | ((ch >> 6) & 0x1f);
+            out[n++] = 0x80 | (ch & 0x3f);
+            continue;
+        }
+        if (ch >= 0xd800 && ch <= 0xdbff) {
+            const ch2 = i + 1 < s.length ? s.charCodeAt(i + 1) : 0;
+            if (ch2 >= 0xdc00 && ch2 <= 0xdfff) {
+                i++;
+                const ucs4 = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000;
+                out[n++] = 0xf0 | ((ucs4 >> 18) & 0x07);
+                out[n++] = 0x80 | ((ucs4 >> 12) & 0x3f);
+                out[n++] = 0x80 | ((ucs4 >> 6) & 0x3f);
+                out[n++] = 0x80 | (ucs4 & 0x3f);
+                continue;
+            }
+            ch = 0xfffd;
+        }
+        else if (ch >= 0xdc00 && ch <= 0xdfff) {
+            ch = 0xfffd;
+        }
+        out[n++] = 0xe0 | ((ch >> 12) & 0x0f);
+        out[n++] = 0x80 | ((ch >> 6) & 0x3f);
+        out[n++] = 0x80 | (ch & 0x3f);
+    }
+    return out.subarray(0, n);
+}
+/**
+ * As UnicodeUtils::Utf8ToUtf16, not strict: a byte that does not start a
+ * valid sequence is the character of its value, and a four-byte sequence
+ * may start with 0xF8 to 0xFF, as Flash Player 9 and 10 read them.
+ */
+/** The length from which fromUtf8 first looks for ASCII. */
+const ASCII_LENGTH = 16;
+export function fromUtf8(bytes) {
+    const n = bytes.length;
+    // ASCII, as most text is: its bytes are its characters. Below
+    // ASCII_LENGTH bytes, a character at a time, until one is not.
+    if (n < ASCII_LENGTH) {
+        let s = "";
+        let k = 0;
+        for (; k < n && bytes[k] < 0x80; k++) {
+            s += String.fromCharCode(bytes[k]);
+        }
+        if (k === n) {
+            return s;
+        }
+    }
+    else {
+        let ascii = 0;
+        while (ascii < n && bytes[ascii] < 0x80) {
+            ascii++;
+        }
+        if (ascii === n) {
+            let s = "";
+            for (let k = 0; k < n; k += 8192) {
+                s += String.fromCharCode.apply(null, bytes.subarray(k, k + 8192));
+            }
+            return s;
+        }
+    }
+    const out = [];
+    let i = 0;
+    while (i < n) {
+        const c = bytes[i];
+        const left = n - i;
+        switch (c >> 4) {
+            case 12:
+            case 13: {
+                if (left >= 2 && (bytes[i + 1] & 0xc0) === 0x80) {
+                    const ch = ((c << 6) & 0x7c0) | (bytes[i + 1] & 0x3f);
+                    if (ch >= 0x80) {
+                        out.push(ch);
+                        i += 2;
+                        continue;
+                    }
+                }
+                break;
+            }
+            case 14: {
+                if (left >= 3 && (bytes[i + 1] & 0xc0) === 0x80 && (bytes[i + 2] & 0xc0) === 0x80) {
+                    const ch = ((c << 12) & 0xf000) | ((bytes[i + 1] << 6) & 0xfc0) | (bytes[i + 2] & 0x3f);
+                    if (ch >= 0x800) {
+                        out.push(ch);
+                        i += 3;
+                        continue;
+                    }
+                }
+                break;
+            }
+            case 15: {
+                if (left >= 4 &&
+                    (bytes[i + 1] & 0xc0) === 0x80 &&
+                    (bytes[i + 2] & 0xc0) === 0x80 &&
+                    (bytes[i + 3] & 0xc0) === 0x80) {
+                    const ch = ((c << 18) & 0x1c0000) |
+                        ((bytes[i + 1] << 12) & 0x3f000) |
+                        ((bytes[i + 2] << 6) & 0xfc0) |
+                        (bytes[i + 3] & 0x3f);
+                    if (ch >= 0x10000) {
+                        out.push((((ch - 0x10000) >> 10) & 0x3ff) + 0xd800, ((ch - 0x10000) & 0x3ff) + 0xdc00);
+                        i += 4;
+                        continue;
+                    }
+                }
+                break;
+            }
+            default:
+                break;
+        }
+        // Not a sequence: the byte itself.
+        out.push(c);
+        i++;
+    }
+    return fromCodes(out);
+}
+/** A string of UTF-16 code units, in chunks, as String.fromCharCode takes only so many arguments. */
+export function fromCodes(units) {
+    let s = "";
+    for (let k = 0; k < units.length; k += 8192) {
+        s += String.fromCharCode(...units.slice(k, k + 8192));
+    }
+    return s;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swf2es/player-hosts",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Optional Node and WebSocket transports, worker threads, an IndexedDB module cache and precompiled modules for the swf2es player",
   "keywords": [
     "swf",
@@ -60,6 +60,6 @@
     "LICENSE.third-party"
   ],
   "dependencies": {
-    "@swf2es/player": "0.1.3"
+    "@swf2es/player": "0.1.5"
   }
 }