@swf2es/player-hosts 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,1227 @@
+// flash.utils.ByteArray and domain memory, as avmplus' ByteArray and
+// 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.
+//
+// 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/.
+import { CompressedDataError, CompressedDataTooLargeError, deflateCompress, LZMA_HEADER, lzmaByteArrayCompress, lzmaByteArrayUncompress, zlibCompress, zlibUncompress, } from "../../../format/index.js";
+import { registerNativeClass } from "./define.js";
+const kGrowthIncr = 4096;
+const kHugeGrowthThreshold = 24 * 1024 * 1024;
+const kHugeGrowthIncr = 24 * 1024 * 1024;
+/**
+ * The most a ByteArray holds: what a 32-bit avmshell, as the oracle's, can
+ * allocate, beyond which it fails with MemoryError 1000, and less than a
+ * browser's ArrayBuffer may be refused at.
+ */
+const kMaxCapacity = 0x80000000;
+/** DomainEnv::GLOBAL_MEMORY_MIN_SIZE: domain memory's least length. */
+export const GLOBAL_MEMORY_MIN_SIZE = 1024;
+const kAMF0 = 0;
+const kAMF3 = 3;
+/** The ways a browser serves a page cross-origin isolated, for the error a page that is not gets. */
+const ISOLATION = "a cross-origin isolated page (served with Cross-Origin-Opener-Policy: same-origin and " +
+    "Cross-Origin-Embedder-Policy: credentialless or require-corp)";
+/**
+ * Whether this thread can share memory with others: SharedArrayBuffer is
+ * there, as node always has it, and a browser only for a page that is
+ * cross-origin isolated.
+ */
+export function canShareMemory() {
+    const g = globalThis;
+    return typeof SharedArrayBuffer === "function" && g.crossOriginIsolated !== false;
+}
+/** What a page that is not cross-origin isolated gets for sharing `what` with another worker. */
+export function notIsolated(what) {
+    return new Error(`swf2es: sharing ${what} with another worker needs shared memory, which a browser gives only ${ISOLATION}`);
+}
+/** Each runtime's ByteArray for each shared memory, by its id. */
+const sharedObjects = new WeakMap();
+function sharedObjectsOf(rt) {
+    let objects = sharedObjects.get(rt);
+    if (!objects) {
+        objects = new Map();
+        sharedObjects.set(rt, objects);
+    }
+    return objects;
+}
+/** The capacity of each runtime's ByteArrays, live or not yet collected. */
+const runtimeCapacity = new WeakMap();
+/** A ByteArray collected: its capacity no longer counted, by its runtime's count and its own. */
+const collected = new FinalizationRegistry(({ runtime, own }) => {
+    runtime.bytes -= own.bytes;
+});
+/** The capacity of `rt`'s ByteArrays, which avmshell's System counts in its memory. */
+export function byteArrayCapacity(rt) {
+    return runtimeCapacity.get(rt)?.bytes ?? 0;
+}
+/**
+ * A ByteArray's state: its buffer, as long as its capacity, and its length
+ * and position. A read or write takes its offset first: growing replaces
+ * the buffer and its view.
+ *
+ * A length or position is stored through `>>> 0`, as a uint32: an int32
+ * while below 2^31, and a double only from there.
+ * JavaScriptCore keeps a number its JIT once made a double a double, and
+ * an addition that has seen one makes doubles from then on: a double
+ * offset fails the int32 check of a DataView or typed array access, and
+ * after enough failures JavaScriptCore calls DataView's methods instead
+ * of inlining them, a quarter slower on every read and write. V8 makes
+ * small integers of them itself.
+ */
+export class Bytes {
+    rt;
+    owner;
+    buffer = new Uint8Array(0);
+    view = new DataView(this.buffer.buffer);
+    length = 0;
+    position = 0;
+    littleEndian = false;
+    /** As ByteArray's constructor: ByteArray.defaultObjectEncoding when it is made. */
+    objectEncoding;
+    /** Whether it is the domain memory, which it then tells when its buffer or length changes. */
+    subscribed = false;
+    /**
+     * Whether `shareable` was set true, which cannot be undone: the
+     * ByteArray then crosses to another worker as its memory, not a copy.
+     */
+    shareable = false;
+    /**
+     * Its memory once it has crossed to another worker (share), which its
+     * buffer and view are then over, tracking its length as it grows; null
+     * until then, when it is a ByteArray like any other.
+     */
+    shared = null;
+    /** The shared memory's words, the length first, and its bytes as words for the atomics. */
+    sharedWords = null;
+    sharedInts = null;
+    /** Its runtime's capacity count, and its own part of it. */
+    capacity;
+    constructor(rt, owner) {
+        this.rt = rt;
+        this.owner = owner;
+        this.objectEncoding = rt.defaultObjectEncoding;
+        let runtime = runtimeCapacity.get(rt);
+        if (!runtime) {
+            runtime = { bytes: 0 };
+            runtimeCapacity.set(rt, runtime);
+        }
+        this.capacity = { runtime, own: { bytes: 0 } };
+        collected.register(this, this.capacity);
+    }
+    /** Its buffer replaced by `next`, its runtime's capacity count with it. */
+    setBuffer(next) {
+        const { runtime, own } = this.capacity;
+        runtime.bytes += next.length - own.bytes;
+        own.bytes = next.length;
+        this.buffer = next;
+        this.view = new DataView(next.buffer);
+    }
+    get available() {
+        return this.length > this.position ? this.length - this.position : 0;
+    }
+    /** As Grower::ReallocBackingStore: a new buffer, the old length's bytes copied and the rest zero. */
+    realloc(capacityIn, minimum, fromSetter) {
+        let capacity = capacityIn;
+        if (capacity < minimum) {
+            capacity = minimum;
+        }
+        if (!(this.buffer.length === 0 && fromSetter) && capacity < kGrowthIncr) {
+            capacity = kGrowthIncr;
+        }
+        if (minimum > kMaxCapacity) {
+            throw this.rt.error("flash.errors::MemoryError", 1000);
+        }
+        capacity = Math.min(capacity, kMaxCapacity);
+        if (capacity === this.buffer.length) {
+            return;
+        }
+        if (this.shared !== null) {
+            this.reshare(capacity);
+            return;
+        }
+        let next;
+        try {
+            next = new Uint8Array(capacity);
+        }
+        catch {
+            // The host would not give it the memory, as the system would not give avmplus.
+            throw this.rt.error("flash.errors::MemoryError", 1000);
+        }
+        next.set(this.buffer.subarray(0, Math.min(capacity, this.length)));
+        this.setBuffer(next);
+    }
+    /** As Grower::EnsureWritableCapacity: double, at least `minimum`, and 4096 unless the setter sizes an empty one. */
+    ensure(minimum, fromSetter) {
+        if (minimum > 0xffffffff - 2 * 4096) {
+            throw this.rt.error("flash.errors::MemoryError", 1000);
+        }
+        if (minimum > this.buffer.length) {
+            this.realloc(this.buffer.length * 2, minimum, fromSetter);
+        }
+    }
+    /** As ByteArray::SetLengthCommon. */
+    setLength(length, fromSetter = false) {
+        if (this.subscribed && length < GLOBAL_MEMORY_MIN_SIZE) {
+            throw this.rt.error("RangeError", 1506);
+        }
+        this.reserve(length, fromSetter);
+        this.length = length >>> 0;
+        if (this.position > length) {
+            this.position = length >>> 0;
+        }
+        this.notify();
+    }
+    /**
+     * The length made at least `length`, as a write past the end makes it:
+     * shared, by a compare and swap that only ever raises it, so that
+     * workers appending at once never lower what another made it.
+     */
+    extend(length) {
+        if (this.shared === null) {
+            this.setLength(length);
+            return;
+        }
+        this.reserve(length, false);
+        this.raise(length);
+        this.notify();
+    }
+    /** A shared length raised to `length` unless another worker made it as long. */
+    raise(length) {
+        const words = this.sharedWords;
+        for (;;) {
+            const now = Atomics.load(words, 0) >>> 0;
+            if (now >= length || Atomics.compareExchange(words, 0, now | 0, length | 0) >>> 0 === now) {
+                return;
+            }
+        }
+    }
+    /** As Grower::SetLengthCommon, before the length is set: the capacity for `length`. */
+    reserve(length, fromSetter) {
+        if (!fromSetter || (length < kHugeGrowthThreshold && this.length < kHugeGrowthThreshold)) {
+            if (length > this.buffer.length) {
+                this.ensure(length, fromSetter);
+            }
+        }
+        else {
+            const rounded = Math.ceil(length / kHugeGrowthIncr) * kHugeGrowthIncr;
+            const capacity = rounded <= 0xffffffff - 2 * 4096 ? rounded : length;
+            if (capacity !== this.buffer.length) {
+                this.realloc(capacity, length, true);
+            }
+        }
+    }
+    /** Tell the domain memory, if this is it, where the bytes are now: a new view only if they moved or their length changed. */
+    notify() {
+        const rt = this.rt;
+        if (this.subscribed &&
+            (rt.memory.buffer !== this.buffer.buffer || rt.memoryLength !== this.length)) {
+            rt.memory = new DataView(this.buffer.buffer, 0, this.length);
+        }
+    }
+    /** As ByteArray::Clear: no buffer at all; shared, every worker's ByteArray for it empty. */
+    clear() {
+        if (this.subscribed) {
+            throw this.rt.error("RangeError", 1506);
+        }
+        this.position = 0;
+        if (this.shared !== null) {
+            // The memory cannot shrink: what it held is zeroed, as a new buffer
+            // would be once it grows again, before the length is told, so that a
+            // worker that grows it once it is empty writes into zeroes already.
+            this.buffer.fill(0);
+            this.length = 0;
+            return;
+        }
+        this.setBuffer(new Uint8Array(0));
+        this.length = 0;
+    }
+    /**
+     * Its memory, shared from now on: a growable SharedArrayBuffer its bytes
+     * move to once, and that this ByteArray, and every worker's ByteArray for
+     * it, uses from then on. Where memory cannot be shared, the error that
+     * names cross-origin isolation.
+     */
+    share() {
+        if (this.shared !== null) {
+            return this.shared;
+        }
+        if (!canShareMemory()) {
+            throw notIsolated("a shareable ByteArray");
+        }
+        const capacity = Math.max(this.buffer.length, this.length);
+        const Shared = SharedArrayBuffer;
+        let data = null;
+        // As much room to grow as a ByteArray has, or as much as the host reserves.
+        for (let max = kMaxCapacity; data === null; max /= 2) {
+            try {
+                data = new Shared(capacity, { maxByteLength: Math.max(max, capacity) });
+            }
+            catch {
+                if (max <= capacity) {
+                    throw this.rt.error("flash.errors::MemoryError", 1000);
+                }
+            }
+        }
+        new Uint8Array(data).set(this.buffer);
+        const memory = {
+            id: Math.floor(Math.random() * 2 ** 52),
+            meta: new SharedArrayBuffer(8),
+            data,
+        };
+        new Int32Array(memory.meta)[0] = this.length | 0;
+        this.adopt(memory);
+        sharedObjectsOf(this.rt).set(memory.id, new WeakRef(this.owner));
+        return memory;
+    }
+    /**
+     * Use `memory`, shared, as its bytes and length from now on. Its length
+     * becomes an accessor of the memory's word on this object alone, so that
+     * every read sees another worker's change and every write is seen, and
+     * a ByteArray that shares nothing reads a plain field as before.
+     */
+    adopt(memory) {
+        this.shared = memory;
+        this.shareable = true;
+        const words = new Int32Array(memory.meta);
+        this.sharedWords = words;
+        Object.defineProperty(this, "length", {
+            get: () => Atomics.load(words, 0) >>> 0,
+            set: (length) => Atomics.store(words, 0, length | 0),
+            configurable: true,
+        });
+        // Views that track the memory's length as any worker grows it.
+        this.buffer = new Uint8Array(memory.data);
+        this.view = new DataView(memory.data);
+        this.sharedInts = new Int32Array(memory.data);
+        const { runtime, own } = this.capacity;
+        runtime.bytes += memory.data.byteLength - own.bytes;
+        own.bytes = memory.data.byteLength;
+        if (this.subscribed) {
+            this.rt.refreshMemory = () => this.notify();
+        }
+        this.notify();
+    }
+    /**
+     * A shared memory's capacity made at least `capacity`: it grows in place,
+     * which every worker sees, and never shrinks, as another worker may have
+     * grown it past what this one asks for since. Nor is what a smaller
+     * buffer would drop zeroed: without avmplus' safepoint, another worker
+     * may have grown the length again and written there meanwhile, so bytes
+     * past a lowered length may come back when it grows again.
+     */
+    reshare(capacity) {
+        const data = this.shared.data;
+        if (capacity <= data.byteLength) {
+            return;
+        }
+        if (capacity > data.maxByteLength) {
+            throw this.rt.error("flash.errors::MemoryError", 1000);
+        }
+        try {
+            data.grow(capacity);
+        }
+        catch {
+            // Another worker grew it meanwhile, to as much or more, or the host refused.
+            if (data.byteLength < capacity) {
+                throw this.rt.error("flash.errors::MemoryError", 1000);
+            }
+        }
+        const { runtime, own } = this.capacity;
+        runtime.bytes += data.byteLength - own.bytes;
+        own.bytes = data.byteLength;
+    }
+    /** As ByteArray::CAS, once the index is checked: atomic where the memory is shared. */
+    compareAndSwapInt(at, expected, next) {
+        if (this.sharedInts !== null) {
+            return Atomics.compareExchange(this.sharedInts, at >> 2, expected, next);
+        }
+        const previous = this.view.getInt32(at, true);
+        if (previous === expected) {
+            this.view.setInt32(at, next, true);
+        }
+        return previous;
+    }
+    /**
+     * As UnprotectedAtomicCompareAndSwapLength: the length set to `next`, as
+     * its setter sets it, if it is `expected`; the length before. Shared,
+     * the capacity is made first and the length swapped atomically, so that
+     * of workers growing it at once one wins.
+     */
+    compareAndSwapLength(expected, next) {
+        if (this.shared === null) {
+            const previous = this.length;
+            if (previous === expected) {
+                this.setLength(next, true);
+            }
+            return previous;
+        }
+        // Read once: another worker may change it between two reads.
+        const now = this.length;
+        if (now !== expected) {
+            return now;
+        }
+        // Only grows the memory, so it does nothing another worker would undo if the swap fails.
+        this.reserve(next, true);
+        const previous = Atomics.compareExchange(this.sharedWords, 0, expected | 0, next | 0) >>> 0;
+        if (previous === expected && this.position > next) {
+            this.position = next;
+        }
+        this.notify();
+        return previous;
+    }
+    /** As requestBytesForShortRead: the offset of `n` bytes to read, or EOFError. */
+    shortRead(n) {
+        const at = this.position;
+        if (at >= this.length || at + n > this.length) {
+            throw this.rt.error("flash.errors::EOFError", 2030);
+        }
+        this.position = (at + n) >>> 0;
+        return at;
+    }
+    /** As requestBytesForShortWrite: the offset of `n` bytes to write, the length grown to hold them. */
+    shortWrite(n) {
+        const at = this.position;
+        if (at >= this.length || at + n > this.length) {
+            if (at + n > 0xffffffff) {
+                throw this.rt.error("flash.errors::MemoryError", 1000);
+            }
+            this.extend(at + n);
+        }
+        this.position = (at + n) >>> 0;
+        return at;
+    }
+    /** As DataInput::CheckEOF. */
+    checkEOF(count) {
+        if (this.available < count) {
+            throw this.rt.error("flash.errors::EOFError", 2030);
+        }
+    }
+    /** As ByteArray::Read: `count` bytes from the position. */
+    read(count) {
+        this.checkEOF(count);
+        const bytes = this.buffer.slice(this.position, this.position + count);
+        this.position = (this.position + count) >>> 0;
+        return bytes;
+    }
+    /** As read, but the bytes themselves, not a copy: for a caller that only reads them, at once. */
+    readView(count) {
+        this.checkEOF(count);
+        const bytes = this.buffer.subarray(this.position, this.position + count);
+        this.position = (this.position + count) >>> 0;
+        return bytes;
+    }
+    /**
+     * As ByteArray::Write: `count` bytes of `source` from `offset`, all of
+     * it by default, at the position; the length grows to the position after.
+     */
+    write(source, offset = 0, count = source.length) {
+        if (count > 0xffffffff - this.position) {
+            throw this.rt.error("flash.errors::MemoryError", 1000);
+        }
+        const end = (this.position + count) >>> 0;
+        if (end > this.buffer.length) {
+            this.ensure(end, false);
+        }
+        copyBytes(this.buffer, this.position, source, offset, count);
+        this.position = end;
+        if (this.length < end) {
+            if (this.shared === null) {
+                this.length = end;
+            }
+            else {
+                this.raise(end);
+            }
+        }
+        this.notify();
+    }
+    /** As ByteArray's operator[] for a write: the length grows to hold `index`. */
+    setByte(index, value) {
+        if (index >= this.length) {
+            if (index === 0xffffffff) {
+                throw this.rt.error("flash.errors::MemoryError", 1000);
+            }
+            this.extend(index + 1);
+        }
+        this.buffer[index] = value;
+    }
+}
+/** Below this many bytes, copyBytes copies one at a time. */
+const COPY_LOOP_LENGTH = 32;
+/**
+ * `count` bytes of `source` from `offset` copied into `target` at `at`,
+ * as memmove copies them where the two are one array. Part of `source`,
+ * fewer than COPY_LOOP_LENGTH bytes, is copied one at a time: the
+ * subarray set() would take costs more than they do, in JavaScriptCore up
+ * to about 64 bytes and in V8 up to about 32. All of it set() copies
+ * faster than a loop in V8, and as fast in JavaScriptCore.
+ */
+function copyBytes(target, at, source, offset, count) {
+    if (source === target) {
+        target.copyWithin(at, offset, offset + count);
+    }
+    else if (offset === 0 && count === source.length) {
+        target.set(source, at);
+    }
+    else if (count < COPY_LOOP_LENGTH) {
+        for (let i = 0; i < count; i++) {
+            target[at + i] = source[offset + i];
+        }
+    }
+    else {
+        target.set(source.subarray(offset, offset + count), at);
+    }
+}
+/** How a ByteArray's elements are indexed: its bytes; past its length undefined, and a write grows it. */
+export const byteArrayHook = {
+    // Its state from the start: it takes defaultObjectEncoding as it is then.
+    create: (traits, rt) => {
+        const o = Object.create(traits.proto);
+        o.$bytes = new Bytes(rt, o);
+        return o;
+    },
+    getIndex: (o, i) => {
+        const b = o.$bytes;
+        return b && i < b.length ? b.buffer[i] : undefined;
+    },
+    setIndex: (o, i, v, rt) => {
+        bytesOf(rt, o).setByte(i, rt.toInt(v) & 0xff);
+    },
+    hasIndex: (o, i) => {
+        const b = o.$bytes;
+        return b !== undefined && i < b.length;
+    },
+};
+/** A ByteArray's state, made the first time a native needs it. */
+export function bytesOf(rt, o) {
+    if (!o.$bytes) {
+        o.$bytes = new Bytes(rt, o);
+    }
+    return o.$bytes;
+}
+/**
+ * A shareable ByteArray's memory, shared from now on, as it crosses to
+ * another worker; where memory cannot be shared, the error that names
+ * cross-origin isolation.
+ */
+export function shareBytes(rt, o) {
+    return bytesOf(rt, o).share();
+}
+/** This VM's one ByteArray for a shared memory, as avmplus interns one for its Buffer: shareable, at position 0. */
+export function sharedByteArray(rt, memory) {
+    const objects = sharedObjectsOf(rt);
+    const known = objects.get(memory.id)?.deref();
+    if (known) {
+        return known;
+    }
+    const o = rt.construct(rt.classNamed("flash.utils::ByteArray"));
+    bytesOf(rt, o).adopt(memory);
+    objects.set(memory.id, new WeakRef(o));
+    return o;
+}
+/** This VM's ByteArray for the shared memory `id`, if it has one. */
+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);
+    return nul < 0 ? bytes : bytes.subarray(0, nul);
+}
+const BOM = (b) => b.length >= 3 && b[0] === 0xef && b[1] === 0xbb && b[2] === 0xbf;
+/** As ByteArrayObject::algorithmToEnum: zlib, deflate or lzma; null a TypeError, any other an IOError. */
+function algorithmOf(rt, algorithm) {
+    if (algorithm === null || algorithm === undefined) {
+        throw rt.error("TypeError", 2007, "algorithm");
+    }
+    const name = rt.toString(algorithm);
+    if (name === "zlib" || name === "deflate" || name === "lzma") {
+        return name;
+    }
+    throw rt.error("flash.errors::IOError", 2058);
+}
+/** A ByteArray's bytes, all of them, replaced by a copy of `bytes`, its position `position`; the domain memory told, if it is. */
+function replaceBytes(b, bytes, position) {
+    if (b.shared !== null) {
+        // In place, for every worker, as avmplus swaps the shared Buffer's array.
+        const previous = b.length;
+        b.position = 0;
+        b.write(bytes);
+        if (previous > bytes.length) {
+            b.buffer.fill(0, bytes.length, previous);
+        }
+        b.length = bytes.length;
+        b.position = position >>> 0;
+        b.notify();
+        return;
+    }
+    b.setBuffer(new Uint8Array(bytes));
+    b.length = bytes.length;
+    b.position = position >>> 0;
+    b.notify();
+}
+/** ByteArray's natives, by the names the compiler gives them. */
+/** ByteArray's natives, for `rt`: written as a class, each running with the ByteArray object as `this`. */
+export function byteArrayNatives(rt) {
+    const own = "flash.utils:ByteArray";
+    const natives = {};
+    const nonNull = (rt, v, name) => {
+        if (v === null || v === undefined) {
+            throw rt.error("TypeError", 2007, name);
+        }
+    };
+    // As ByteArrayObject::readUTFBytes: a BOM skipped, and a NUL ends the string.
+    const readUTFBytes = (rt, b, n) => {
+        if (b.available < n) {
+            throw rt.error("flash.errors::EOFError", 2030);
+        }
+        let bytes = b.buffer.subarray(b.position, b.position + n);
+        if (BOM(bytes)) {
+            bytes = bytes.subarray(3);
+        }
+        const s = fromUtf8(toNul(bytes));
+        b.position = (b.position + n) >>> 0;
+        return s;
+    };
+    class ByteArrayNatives {
+        static get defaultObjectEncoding() {
+            return rt.defaultObjectEncoding;
+        }
+        static set defaultObjectEncoding(v) {
+            const e = rt.toUint(v);
+            if (e !== kAMF0 && e !== kAMF3) {
+                throw rt.error("ArgumentError", 2008, "objectEncoding");
+            }
+            rt.defaultObjectEncoding = e;
+        }
+        get length() {
+            const b = bytesOf(rt, this);
+            return b.length;
+        }
+        set length(v) {
+            const b = bytesOf(rt, this);
+            b.setLength(rt.toUint(v), true);
+        }
+        get position() {
+            const b = bytesOf(rt, this);
+            return b.position;
+        }
+        set position(v) {
+            const b = bytesOf(rt, this);
+            // Not redundant: toUint's own `>>> 0` serves every caller, and once
+            // one passes it 2^31 or more, JavaScriptCore makes doubles there for
+            // all of them (see Bytes).
+            b.position = rt.toUint(v) >>> 0;
+        }
+        get bytesAvailable() {
+            const b = bytesOf(rt, this);
+            return b.available;
+        }
+        get endian() {
+            const b = bytesOf(rt, this);
+            return b.littleEndian ? "littleEndian" : "bigEndian";
+        }
+        set endian(v) {
+            const b = bytesOf(rt, this);
+            nonNull(rt, v, "endian");
+            const type = rt.toString(v);
+            if (type === "bigEndian" || type === "littleEndian") {
+                b.littleEndian = type === "littleEndian";
+            }
+            else {
+                throw rt.error("ArgumentError", 2008, "type");
+            }
+        }
+        get objectEncoding() {
+            const b = bytesOf(rt, this);
+            return b.objectEncoding;
+        }
+        set objectEncoding(v) {
+            const b = bytesOf(rt, this);
+            const e = rt.toUint(v);
+            if (e !== kAMF0 && e !== kAMF3) {
+                throw rt.error("ArgumentError", 2008, "objectEncoding");
+            }
+            b.objectEncoding = e;
+        }
+        get shareable() {
+            return bytesOf(rt, this).shareable;
+        }
+        // As ByteArray::setShareable: once shareable, always; its memory is
+        // shared when it first crosses to another worker.
+        set shareable(v) {
+            if (rt.toBoolean(v)) {
+                bytesOf(rt, this).shareable = true;
+            }
+        }
+        clear() {
+            const b = bytesOf(rt, this);
+            b.clear();
+        }
+        // As ByteArray::CAS: the int at a word-aligned index within the bytes,
+        // replaced by `next` if it is `expected`; the int there before.
+        atomicCompareAndSwapIntAt(index, expected, next) {
+            const b = bytesOf(rt, this);
+            const at = rt.toInt(index) >>> 0;
+            if (b.length < 4 || at > b.length - 4 || at % 4 !== 0) {
+                throw rt.error("RangeError", 1506);
+            }
+            return b.compareAndSwapInt(at, rt.toInt(expected), rt.toInt(next));
+        }
+        // As ByteArrayObject::atomicCompareAndSwapLength: the length set to
+        // `next` if it is `expected`, as its setter sets it; the length before.
+        // The domain memory refuses a length below its least, as later avmplus
+        // does; the oracle's avmshell sets it.
+        atomicCompareAndSwapLength(expected, next) {
+            const b = bytesOf(rt, this);
+            const length = rt.toInt(next);
+            if (b.subscribed && length < GLOBAL_MEMORY_MIN_SIZE) {
+                throw rt.error("RangeError", 1506);
+            }
+            return b.compareAndSwapLength(rt.toInt(expected), length >>> 0);
+        }
+        // Reads.
+        readBoolean() {
+            const b = bytesOf(rt, this);
+            const at = b.shortRead(1);
+            return b.buffer[at] !== 0;
+        }
+        readByte() {
+            const b = bytesOf(rt, this);
+            const at = b.shortRead(1);
+            return b.view.getInt8(at);
+        }
+        readUnsignedByte() {
+            const b = bytesOf(rt, this);
+            const at = b.shortRead(1);
+            return b.buffer[at];
+        }
+        readShort() {
+            const b = bytesOf(rt, this);
+            const at = b.shortRead(2);
+            return b.view.getInt16(at, b.littleEndian);
+        }
+        readUnsignedShort() {
+            const b = bytesOf(rt, this);
+            const at = b.shortRead(2);
+            return b.view.getUint16(at, b.littleEndian);
+        }
+        readInt() {
+            const b = bytesOf(rt, this);
+            const at = b.shortRead(4);
+            return b.view.getInt32(at, b.littleEndian);
+        }
+        readUnsignedInt() {
+            const b = bytesOf(rt, this);
+            const at = b.shortRead(4);
+            return b.view.getUint32(at, b.littleEndian);
+        }
+        readFloat() {
+            const b = bytesOf(rt, this);
+            const at = b.shortRead(4);
+            return b.view.getFloat32(at, b.littleEndian);
+        }
+        readDouble() {
+            const b = bytesOf(rt, this);
+            const at = b.shortRead(8);
+            return b.view.getFloat64(at, b.littleEndian);
+        }
+        readUTFBytes(n) {
+            const b = bytesOf(rt, this);
+            return readUTFBytes(rt, b, rt.toUint(n));
+        }
+        readUTF() {
+            const b = bytesOf(rt, this);
+            const at = b.shortRead(2);
+            return readUTFBytes(rt, b, b.view.getUint16(at, b.littleEndian));
+        }
+        // avmshell converts no other charset: the bytes are checked, and nothing read.
+        readMultiByte(n, charSet) {
+            const b = bytesOf(rt, this);
+            nonNull(rt, charSet, "charSet");
+            b.checkEOF(rt.toUint(n));
+            return "";
+        }
+        // As DataInput::ReadByteArray: into `bytes` at `offset`, growing it to hold them.
+        readBytes(bytes, offsetIn = 0, lengthIn = 0) {
+            const b = bytesOf(rt, this);
+            nonNull(rt, bytes, "bytes");
+            const offset = rt.toUint(offsetIn);
+            let count = rt.toUint(lengthIn);
+            const available = b.available;
+            if (count === 0) {
+                count = available;
+            }
+            if (count > available) {
+                throw rt.error("flash.errors::EOFError", 2030);
+            }
+            if (offset + count > 0xffffffff) {
+                throw rt.error("RangeError", 2006);
+            }
+            // From the buffer as it is now: a target that grows, this ByteArray
+            // too, gets a new buffer, and the bytes come from the old one. As in
+            // DataInput::ReadByteArray, the target is sized first: one that
+            // cannot grow leaves the position where it was.
+            const to = bytesOf(rt, bytes);
+            const source = b.buffer;
+            const from = b.position;
+            if (offset + count >= to.length) {
+                to.extend(offset + count);
+            }
+            b.position = (from + count) >>> 0;
+            copyBytes(to.buffer, offset, source, from, count);
+        }
+        // Writes.
+        writeBoolean(v) {
+            const b = bytesOf(rt, this);
+            const at = b.shortWrite(1);
+            b.buffer[at] = v ? 1 : 0;
+        }
+        writeByte(v) {
+            const b = bytesOf(rt, this);
+            const at = b.shortWrite(1);
+            b.buffer[at] = rt.toInt(v) & 0xff;
+        }
+        writeShort(v) {
+            const b = bytesOf(rt, this);
+            const at = b.shortWrite(2);
+            b.view.setInt16(at, rt.toInt(v), b.littleEndian);
+        }
+        writeInt(v) {
+            const b = bytesOf(rt, this);
+            const at = b.shortWrite(4);
+            b.view.setInt32(at, rt.toInt(v), b.littleEndian);
+        }
+        writeUnsignedInt(v) {
+            const b = bytesOf(rt, this);
+            const at = b.shortWrite(4);
+            b.view.setUint32(at, rt.toUint(v), b.littleEndian);
+        }
+        writeFloat(v) {
+            const b = bytesOf(rt, this);
+            const at = b.shortWrite(4);
+            b.view.setFloat32(at, rt.toNumber(v), b.littleEndian);
+        }
+        writeDouble(v) {
+            const b = bytesOf(rt, this);
+            const at = b.shortWrite(8);
+            b.view.setFloat64(at, rt.toNumber(v), b.littleEndian);
+        }
+        writeUTFBytes(v) {
+            const b = bytesOf(rt, this);
+            nonNull(rt, v, "value");
+            b.write(utf8(rt.toString(v)));
+        }
+        writeUTF(v) {
+            const b = bytesOf(rt, this);
+            nonNull(rt, v, "value");
+            const bytes = utf8(rt.toString(v));
+            if (bytes.length > 65535) {
+                throw rt.error("RangeError", 2006);
+            }
+            const at = b.shortWrite(2);
+            b.view.setUint16(at, bytes.length, b.littleEndian);
+            b.write(bytes);
+        }
+        writeMultiByte(value, charSet) {
+            nonNull(rt, value, "value");
+            nonNull(rt, charSet, "charSet");
+        }
+        // As ByteArrayObject::writeBytes and DataOutput::WriteByteArray.
+        writeBytes(bytes, offsetIn = 0, lengthIn = 0) {
+            const b = bytesOf(rt, this);
+            nonNull(rt, bytes, "bytes");
+            const from = bytesOf(rt, bytes);
+            let offset = rt.toUint(offsetIn);
+            let count = rt.toUint(lengthIn);
+            if (count === 0) {
+                count = (from.length - offset) >>> 0;
+            }
+            const length = from.length;
+            if (offset > length) {
+                offset = length;
+            }
+            if (count === 0) {
+                count = length - offset;
+            }
+            if (count > length - offset) {
+                throw rt.error("RangeError", 2006);
+            }
+            if (count > 0) {
+                b.write(from.buffer, offset, count);
+            }
+        }
+        // As ByteArrayObject::_compress and _uncompress, which compress(),
+        // uncompress(), deflate() and inflate() call: the algorithm checked
+        // first, and an empty ByteArray left as it is. The domain memory is
+        // compressed too, as avmshell's is: its Domain does not subscribe to it
+        // as the player refuses a subscribed one (3735). Compressing leaves the position at the end, uncompressing at 0;
+        // data that does not uncompress leaves the ByteArray as it was.
+        [`${own}::_compress`](algorithm) {
+            const kind = algorithmOf(rt, algorithm);
+            const b = bytesOf(rt, this);
+            if (b.length === 0) {
+                return;
+            }
+            const data = b.buffer.subarray(0, b.length);
+            const out = kind === "zlib"
+                ? zlibCompress(data)
+                : kind === "deflate"
+                    ? deflateCompress(data)
+                    : lzmaByteArrayCompress(data);
+            replaceBytes(b, out, out.length);
+        }
+        [`${own}::_uncompress`](algorithm) {
+            const kind = algorithmOf(rt, algorithm);
+            const b = bytesOf(rt, this);
+            if (b.length === 0) {
+                return;
+            }
+            const data = b.buffer.subarray(0, b.length);
+            let out;
+            if (kind === "lzma") {
+                // As UncompressViaLzma: too short for its header is left as it is, and
+                // a length past 32 bits a MemoryError before anything is read.
+                if (b.length < LZMA_HEADER) {
+                    return;
+                }
+                if (data[9] | data[10] | data[11] | data[12]) {
+                    throw rt.error("flash.errors::MemoryError", 1000);
+                }
+            }
+            try {
+                out =
+                    kind === "lzma"
+                        ? lzmaByteArrayUncompress(data)
+                        : zlibUncompress(data, kind === "deflate");
+            }
+            catch (e) {
+                // As avmplus: an output it cannot allocate is a MemoryError, corrupt data an IOError.
+                if (e instanceof CompressedDataTooLargeError) {
+                    throw rt.error("flash.errors::MemoryError", 1000);
+                }
+                if (e instanceof CompressedDataError) {
+                    throw rt.error("flash.errors::IOError", 2058);
+                }
+                throw e;
+            }
+            replaceBytes(b, out, 0);
+        }
+        // As ByteArrayObject::_toString: by its BOM, UTF-8 or UTF-16 of either
+        // order, else UTF-8; all of its length, NULs too.
+        [`${own}::_toString`]() {
+            const b = bytesOf(rt, this);
+            const bytes = b.buffer.subarray(0, b.length);
+            if (bytes.length >= 3) {
+                if (BOM(bytes)) {
+                    return fromUtf8(bytes.subarray(3));
+                }
+                if ((bytes[0] === 0xfe && bytes[1] === 0xff) || (bytes[0] === 0xff && bytes[1] === 0xfe)) {
+                    const little = bytes[0] === 0xff;
+                    const units = [];
+                    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+                    for (let i = 2; i + 1 < bytes.length; i += 2) {
+                        units.push(view.getUint16(i, little));
+                    }
+                    return fromCodes(units);
+                }
+            }
+            return fromUtf8(bytes);
+        }
+    }
+    registerNativeClass(natives, "flash.utils::ByteArray", ByteArrayNatives);
+    // flash.utils' ObjectOutput and ObjectInput, what writeExternal and
+    // readExternal are given: the ByteArray's own writes and reads, in the
+    // stream's byte order, and its objects through the stream's tables.
+    const delegated = (target, names) => {
+        const from = ByteArrayNatives.prototype;
+        for (const name of names) {
+            const f = from[name];
+            Object.defineProperty(target, name, {
+                value(...args) {
+                    const stream = this.$amf;
+                    const b = stream.bytes;
+                    const order = b.littleEndian;
+                    b.littleEndian = stream.littleEndian;
+                    try {
+                        return f.apply(b.owner, args);
+                    }
+                    finally {
+                        b.littleEndian = order;
+                    }
+                },
+            });
+        }
+    };
+    const streamState = {
+        get endian() {
+            return this.$amf.littleEndian ? "littleEndian" : "bigEndian";
+        },
+        set endian(v) {
+            nonNull(rt, v, "endian");
+            if (v !== "bigEndian" && v !== "littleEndian") {
+                throw rt.error("ArgumentError", 2008, "type");
+            }
+            this.$amf.littleEndian = v === "littleEndian";
+        },
+        get objectEncoding() {
+            return this.$amf.objectEncoding;
+        },
+        set objectEncoding(v) {
+            const encoding = rt.toUint(v);
+            if (encoding !== 0 && encoding !== 3) {
+                throw rt.error("ArgumentError", 2008, "objectEncoding");
+            }
+            this.$amf.objectEncoding = encoding;
+        },
+    };
+    class ObjectOutputNatives {
+        writeObject(v) {
+            const stream = this.$amf;
+            if (stream.objectEncoding !== 3) {
+                throw rt.unsupported("AMF0");
+            }
+            stream.value(v);
+        }
+    }
+    class ObjectInputNatives {
+        readObject() {
+            const stream = this.$amf;
+            if (stream.objectEncoding !== 3) {
+                throw rt.unsupported("AMF0");
+            }
+            return stream.value();
+        }
+        get bytesAvailable() {
+            return this.$amf.bytes.available;
+        }
+    }
+    for (const Class of [ObjectOutputNatives, ObjectInputNatives]) {
+        Object.defineProperties(Class.prototype, Object.getOwnPropertyDescriptors(streamState));
+    }
+    delegated(ObjectOutputNatives.prototype, [
+        "writeBytes",
+        "writeBoolean",
+        "writeByte",
+        "writeShort",
+        "writeInt",
+        "writeUnsignedInt",
+        "writeFloat",
+        "writeDouble",
+        "writeMultiByte",
+        "writeUTF",
+        "writeUTFBytes",
+    ]);
+    delegated(ObjectInputNatives.prototype, [
+        "readBytes",
+        "readBoolean",
+        "readByte",
+        "readUnsignedByte",
+        "readShort",
+        "readUnsignedShort",
+        "readInt",
+        "readUnsignedInt",
+        "readFloat",
+        "readDouble",
+        "readMultiByte",
+        "readUTF",
+        "readUTFBytes",
+    ]);
+    registerNativeClass(natives, "flash.utils::ObjectOutput", ObjectOutputNatives);
+    registerNativeClass(natives, "flash.utils::ObjectInput", ObjectInputNatives);
+    return natives;
+}
+/**
+ * As DomainEnv::set_globalMemory: the domain memory set to ByteArray `v`, or
+ * to the scratch memory for null; a ByteArray shorter than the least length
+ * fails. avmshell's Domain and the player's ApplicationDomain both set it.
+ */
+export function setDomainMemory(rt, v) {
+    const previous = rt.memoryProvider;
+    if (v === null || v === undefined) {
+        if (previous) {
+            bytesOf(rt, previous).subscribed = false;
+        }
+        rt.memoryProvider = null;
+        rt.refreshMemory = null;
+        rt.memory = rt.scratchMemory;
+        return;
+    }
+    const b = bytesOf(rt, v);
+    if (b.length < GLOBAL_MEMORY_MIN_SIZE) {
+        throw rt.error("Error", 1504);
+    }
+    b.subscribed = true;
+    b.notify();
+    if (previous && previous !== v) {
+        bytesOf(rt, previous).subscribed = false;
+    }
+    rt.memoryProvider = v;
+    // Shared, its length as the other workers left it, its view made again if it changed.
+    rt.refreshMemory = b.shared !== null ? () => b.notify() : null;
+}