@swf2es/runtime 0.1.19 → 0.1.21

package/dist/avm2/natives/bytearray.d.ts

@@ -3,164 +3,10 @@ import type { IndexHook } from "../hooks.js";
 import type { Runtime } from "../runtime.js";
 import type { Traits } from "../traits.js";
 import { type Natives } from "./define.js";
-/** DomainEnv::GLOBAL_MEMORY_MIN_SIZE: domain memory's least length. */
-export declare const GLOBAL_MEMORY_MIN_SIZE = 1024;
-/**
- * A shareable ByteArray's memory once it has crossed to another worker,
- * which every worker's ByteArray for it uses, as avmplus' ByteArrays share
- * one Buffer: its bytes grow in place, and its length is one for all.
- * Plain data, which a structured clone carries to another thread.
- */
-export interface SharedBytesMemory {
-    /** The same in every worker, by which each VM keeps one ByteArray for it, as avmplus interns it. */
-    id: number;
-    /** Its words: the length, as a uint32. */
-    meta: SharedArrayBuffer;
-    /** Its bytes, as long as its capacity: growable, up to the most a ByteArray holds where it can. */
-    data: SharedArrayBuffer;
-}
-/**
- * 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 declare function canShareMemory(): boolean;
-/** What a page that is not cross-origin isolated gets for sharing `what` with another worker. */
-export declare function notIsolated(what: string): Error;
-/** The capacity of `rt`'s ByteArrays, which avmshell's System counts in its memory. */
-export declare function byteArrayCapacity(rt: Runtime): number;
-/**
- * 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 declare class Bytes {
-    readonly rt: Runtime;
-    readonly owner: AsObject;
-    buffer: Uint8Array;
-    view: DataView<ArrayBufferLike>;
-    length: number;
-    position: number;
-    littleEndian: boolean;
-    /** As ByteArray's constructor: ByteArray.defaultObjectEncoding when it is made. */
-    objectEncoding: number;
-    /** Whether it is the domain memory, which it then tells when its buffer or length changes. */
-    subscribed: boolean;
-    /**
-     * Whether `shareable` was set true, which cannot be undone: the
-     * ByteArray then crosses to another worker as its memory, not a copy.
-     */
-    shareable: boolean;
-    /**
-     * 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: SharedBytesMemory | null;
-    /** The shared memory's words, the length first, and its bytes as words for the atomics. */
-    private sharedWords;
-    private sharedInts;
-    /** Its runtime's capacity count, and its own part of it. */
-    private readonly capacity;
-    constructor(rt: Runtime, owner: AsObject);
-    /** Its buffer replaced by `next`, its runtime's capacity count with it. */
-    setBuffer(next: Uint8Array<ArrayBuffer>): void;
-    get available(): number;
-    /** As Grower::ReallocBackingStore: a new buffer, the old length's bytes copied and the rest zero. */
-    private realloc;
-    /** As Grower::EnsureWritableCapacity: double, at least `minimum`, and 4096 unless the setter sizes an empty one. */
-    private ensure;
-    /** As ByteArray::SetLengthCommon. */
-    setLength(length: number, fromSetter?: boolean): void;
-    /**
-     * 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: number): void;
-    /** A shared length raised to `length` unless another worker made it as long. */
-    private raise;
-    /** As Grower::SetLengthCommon, before the length is set: the capacity for `length`. */
-    private reserve;
-    /** 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(): void;
-    /** As ByteArray::Clear: no buffer at all; shared, every worker's ByteArray for it empty. */
-    clear(): void;
-    /**
-     * 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(): SharedBytesMemory;
-    /**
-     * 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: SharedBytesMemory): void;
-    /**
-     * 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.
-     */
-    private reshare;
-    /** As ByteArray::CAS, once the index is checked: atomic where the memory is shared. */
-    compareAndSwapInt(at: number, expected: number, next: number): number;
-    /**
-     * 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: number, next: number): number;
-    /** As requestBytesForShortRead: the offset of `n` bytes to read, or EOFError. */
-    shortRead(n: number): number;
-    /** As requestBytesForShortWrite: the offset of `n` bytes to write, the length grown to hold them. */
-    shortWrite(n: number): number;
-    /** As DataInput::CheckEOF. */
-    checkEOF(count: number): void;
-    /** As ByteArray::Read: `count` bytes from the position. */
-    read(count: number): Uint8Array;
-    /** As read, but the bytes themselves, not a copy: for a caller that only reads them, at once. */
-    readView(count: number): Uint8Array;
-    /**
-     * 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: Uint8Array, offset?: number, count?: number): void;
-    /** As ByteArray's operator[] for a write: the length grows to hold `index`. */
-    setByte(index: number, value: number): void;
-}
 /** How a ByteArray's elements are indexed: its bytes; past its length undefined, and a write grows it. */
 export declare const byteArrayHook: IndexHook & {
     create: (traits: Traits, rt: Runtime) => AsObject;
 };
-/** A ByteArray's state, made the first time a native needs it. */
-export declare function bytesOf(rt: Runtime, o: AsObject): 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 declare function shareBytes(rt: Runtime, o: AsObject): SharedBytesMemory;
-/** This VM's one ByteArray for a shared memory, as avmplus interns one for its Buffer: shareable, at position 0. */
-export declare function sharedByteArray(rt: Runtime, memory: SharedBytesMemory): AsObject;
-/** This VM's ByteArray for the shared memory `id`, if it has one. */
-export declare function knownSharedByteArray(rt: Runtime, id: number): AsObject | undefined;
 /** 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 declare function byteArrayNatives(rt: Runtime): Natives;

package/dist/avm2/natives/bytearray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bytearray.d.ts","sourceRoot":"","sources":["../../../src/avm2/natives/bytearray.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"bytearray.d.ts","sourceRoot":"","sources":["../../../src/avm2/natives/bytearray.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,QAAQ,EAAU,KAAK,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAG3C,OAAO,EAAE,KAAK,OAAO,EAAuB,MAAM,aAAa,CAAC;AAKhE,0GAA0G;AAC1G,eAAO,MAAM,aAAa,EAAE,SAAS,GAAG;IAAE,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,KAAK,QAAQ,CAAA;CAkB1F,CAAC;AAkDF,iEAAiE;AACjE,2GAA2G;AAC3G,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAojBrD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,GAAG,IAAI,CA2B3D"}

package/dist/avm2/natives/bytearray.js

@@ -10,473 +10,10 @@
 // http://mozilla.org/MPL/2.0/.
 import { CompressedDataError, CompressedDataTooLargeError, deflateCompress, LZMA_HEADER, lzmaByteArrayCompress, lzmaByteArrayUncompress, zlibCompress, zlibUncompress, } from "@swf2es/format";
 import { fromCodes, fromUtf8, utf8 } from "../utf8.js";
+import { Bytes, bytesOf, copyBytes, GLOBAL_MEMORY_MIN_SIZE } from "./bytes.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.
@@ -497,37 +34,6 @@ export const byteArrayHook = {
         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 longest string readUTFBytes reads a character at a time. */
 const SHORT_STRING = 24;
 /** The bytes up to the first NUL, as avmplus reads a C string. */