@swf2es/player-hosts 0.0.0-stage → 0.1.0

package/dist/thread/player/playerglobal/flash/filesystem/FileStream.js

@@ -0,0 +1,453 @@
+// flash.filesystem.FileStream over the host's FileSystemHost (hosts.ts),
+// as adl (AIR 51.3, Windows) has it. A stream holds its file's bytes in a
+// ByteArray, whose DataInput and DataOutput it reads and writes with, as
+// URLStream's does. READ reads the file; WRITE empties it or makes it;
+// APPEND writes only at its end, whose position cannot be set; UPDATE
+// reads and writes it, from its start. WRITE and APPEND read nothing, nor
+// tell bytesAvailable (IOError 2029, as a stream not open, and READ's
+// writes and truncate). The modes that write make the file, and the
+// directories it is in. What is written reaches the file as adl's does,
+// at the end of the frame and at close, and a write to a file of the
+// app: URL is a SecurityError. open does all this at once and throws its
+// errors; openAsync does it on the next frame and reports them as an
+// ioError event, then hands a file being read over a 40960-byte chunk a
+// frame, each with a progress event, and complete (READ and UPDATE), and
+// tells what it wrote with outputProgress, as adl's do. A missing file is
+// IOError 3003 to read, a directory 3006, and a directory a file in the
+// way 3003 to write. Windows' AIR also refuses to open a file another
+// stream has open to write (IOError 3013), which macOS' does not; nor
+// does this.
+import { avm2 } from "../../../../runtime/index.js";
+import { dispatchEvent } from "../../../scripting/events.js";
+import { fileLocation } from "./File.js";
+import { ioErrorEvent, openRefusal, refuseApp, writeFile } from "./writes.js";
+/** How much of an asynchronously opened file a frame hands over, as adl's reads do. */
+const CHUNK = 40960;
+const MODES = ["read", "write", "append", "update"];
+const EMPTY = new Uint8Array(0);
+export function fileStreamNatives(s) {
+    const natives = {};
+    const host = s.fileSystem;
+    const notOpen = () => {
+        throw s.rt.error("flash.errors::IOError", 2029);
+    };
+    /** The open stream's buffer; IOError 2029 for one not open. */
+    const opened = (stream) => stream.$buffer ?? notOpen();
+    /** The buffer of a stream that reads; IOError 2029 for one not open or in WRITE or APPEND mode. */
+    const reading = (stream) => {
+        const buffer = opened(stream);
+        return stream.$mode === "write" || stream.$mode === "append" ? notOpen() : buffer;
+    };
+    /** The buffer of a stream that writes; IOError 2029 for one not open or in READ mode. */
+    const writing = (stream) => {
+        const buffer = opened(stream);
+        return stream.$mode === "read" ? notOpen() : buffer;
+    };
+    const read = (stream, method, ...args) => s.rt.callProperty(reading(stream), s.rt.publicName(method), ...args);
+    const write = (stream, method, ...args) => {
+        const bytes = avm2.bytesOf(s.rt, writing(stream));
+        // A write past the end leaves zeros before it, which the file, made as long, has too.
+        const from = bytes.position;
+        s.rt.callProperty(stream.$buffer, s.rt.publicName(method), ...args);
+        stream.$written = (stream.$written ?? 0) + (bytes.position - from);
+        changed(stream, from, bytes.position);
+    };
+    const event = (stream, e) => dispatchEvent(s, stream, e);
+    const outputProgress = (stream) => event(stream, s.rt.construct(s.rt.classNamed("flash.events::OutputProgressEvent"), "outputProgress", false, false, 0, stream.$written ?? 0));
+    /** Marks `from` to `to` of `stream`'s bytes, and its length, for the file, at the end of the frame. */
+    const changed = (stream, from, to) => {
+        stream.$from = Math.min(stream.$from ?? from, from);
+        stream.$to = Math.max(stream.$to ?? to, to);
+        if (stream.$flushing) {
+            return;
+        }
+        stream.$flushing = true;
+        const generation = stream.$generation;
+        s.loads.deferHostEvent(() => {
+            // An open since has its own.
+            if (stream.$generation !== generation) {
+                return;
+            }
+            stream.$flushing = false;
+            if (flush(stream) && stream.$async) {
+                outputProgress(stream);
+            }
+        });
+    };
+    /** What `stream` changed, given to its file: whether there was any. */
+    const flush = (stream) => {
+        if (stream.$from === undefined || !stream.$buffer || !stream.$made) {
+            return false;
+        }
+        const bytes = avm2.bytesOf(s.rt, stream.$buffer);
+        const from = Math.min(stream.$from, bytes.length);
+        const to = Math.max(from, Math.min(stream.$to ?? from, bytes.length));
+        stream.$from = undefined;
+        stream.$to = undefined;
+        writeFile(s, stream.$path, bytes.buffer.subarray(from, to), from, bytes.length);
+        return true;
+    };
+    /**
+     * The native path of `file` and its mode, or why it cannot be opened in
+     * it: what open and openAsync throw at once (no File, no path, no such
+     * mode, a mode that writes a file of the app: URL).
+     */
+    const target = (file, mode) => {
+        if (file === null || file === undefined) {
+            throw s.rt.error("TypeError", 2007, "file");
+        }
+        const at = fileLocation(file);
+        if (!at) {
+            throw s.rt.error("flash.errors::IllegalOperationError", 2037);
+        }
+        const named = s.rt.toString(mode);
+        if (!MODES.includes(named)) {
+            throw s.rt.error("ArgumentError", 2004);
+        }
+        if (named !== "read") {
+            refuseApp(s, at);
+        }
+        return { path: at.path, mode: named };
+    };
+    /** What a READ finds at `path`: 3003 for nothing there, 3006 for a directory, or the bytes. */
+    const contents = (path) => {
+        const stat = host?.stat(path);
+        if (!stat) {
+            return 3003;
+        }
+        if (stat.directory) {
+            return 3006;
+        }
+        return host?.read?.(path) ?? 3003;
+    };
+    /**
+     * Makes the file at `path` for `mode`, which writes: emptied for WRITE,
+     * as it was for the others, there now. The IOError why it cannot be, or
+     * what it held before.
+     */
+    const make = (path, mode) => {
+        const refusal = openRefusal(s, path);
+        if (refusal) {
+            return refusal;
+        }
+        // A file there that cannot be read is not emptied by a mode that keeps it.
+        const there = !!host?.stat(path);
+        const before = mode === "write" || !there ? EMPTY : host?.read?.(path);
+        if (!before) {
+            return 3001;
+        }
+        return writeFile(s, path, EMPTY, before.length, before.length) ? before : 3001;
+    };
+    /**
+     * A new buffer for `stream`, empty, with its endian and object encoding,
+     * open on `path` in `mode`, in place of any open one, which has given its
+     * file what it wrote.
+     */
+    const reopen = (stream, async, path, mode) => {
+        flush(stream);
+        stream.$generation = (stream.$generation ?? 0) + 1;
+        const buffer = s.rt.construct(s.rt.classNamed("flash.utils::ByteArray"));
+        s.rt.setProperty(buffer, s.rt.publicName("endian"), stream.$endian ?? "bigEndian");
+        s.rt.setProperty(buffer, s.rt.publicName("objectEncoding"), stream.$objectEncoding ?? 3);
+        stream.$buffer = buffer;
+        stream.$async = async;
+        stream.$path = path;
+        stream.$mode = mode;
+        stream.$made = !async;
+        stream.$from = undefined;
+        stream.$to = undefined;
+        stream.$flushing = false;
+        stream.$written = 0;
+        return buffer;
+    };
+    /** Closes `stream`, what it wrote given to its file, and stops what its open had yet to do. */
+    const shut = (stream) => {
+        const wrote = flush(stream);
+        stream.$buffer = null;
+        stream.$generation = (stream.$generation ?? 0) + 1;
+        return wrote;
+    };
+    /**
+     * Puts `bytes`, the file's from `at`, in the buffer of `stream`, its
+     * position kept: but where the stream wrote before the file was read in,
+     * what it wrote stands.
+     */
+    const merge = (stream, bytes, at) => {
+        const into = avm2.bytesOf(s.rt, stream.$buffer);
+        const position = into.position;
+        const from = Math.max(at, stream.$from ?? Number.POSITIVE_INFINITY);
+        const to = Math.min(at + bytes.length, stream.$to ?? 0, into.length);
+        const written = from < to ? into.buffer.slice(from, to) : null;
+        into.position = at;
+        into.write(bytes);
+        if (written) {
+            into.position = from;
+            into.write(written);
+        }
+        into.position = position;
+    };
+    /** Puts `bytes` in the buffer of `stream`, its position at their start, or for APPEND their end. */
+    const fill = (stream, bytes) => {
+        const into = avm2.bytesOf(s.rt, stream.$buffer);
+        into.write(bytes);
+        into.position = stream.$mode === "append" ? into.length : 0;
+    };
+    /**
+     * Hands `bytes` to `stream` a chunk a frame, each in its place with a
+     * progress event, then complete, while the open of `generation` lasts;
+     * `done` before complete.
+     */
+    const deliver = (stream, bytes, generation, done) => {
+        const current = () => stream.$generation === generation;
+        let loaded = 0;
+        const next = () => {
+            if (!current()) {
+                return;
+            }
+            const end = Math.min(loaded + CHUNK, bytes.length);
+            merge(stream, bytes.subarray(loaded, end), loaded);
+            loaded = end;
+            event(stream, s.rt.construct(s.rt.classNamed("flash.events::ProgressEvent"), "progress", false, false, loaded, bytes.length));
+            if (!current()) {
+                return;
+            }
+            if (loaded < bytes.length) {
+                s.loads.deferHostEvent(next);
+            }
+            else {
+                done();
+                event(stream, s.event("complete"));
+            }
+        };
+        s.loads.deferHostEvent(next);
+    };
+    class FileStreamNatives {
+        open(file, mode) {
+            const at = target(file, mode);
+            const bytes = at.mode === "read" ? contents(at.path) : make(at.path, at.mode);
+            if (typeof bytes === "number") {
+                shut(this);
+                throw s.rt.error("flash.errors::IOError", bytes);
+            }
+            reopen(this, false, at.path, at.mode);
+            fill(this, bytes);
+        }
+        openAsync(file, mode) {
+            const at = target(file, mode);
+            reopen(this, true, at.path, at.mode);
+            const generation = this.$generation;
+            const failed = (id) => {
+                shut(this);
+                event(this, ioErrorEvent(s, id, ` file: ${at.path}`));
+            };
+            if (at.mode === "read") {
+                const bytes = contents(at.path);
+                s.loads.deferHostEvent(() => {
+                    if (this.$generation !== generation) {
+                        return;
+                    }
+                    if (typeof bytes === "number") {
+                        failed(bytes);
+                    }
+                    else {
+                        deliver(this, bytes, generation, () => { });
+                    }
+                });
+                return;
+            }
+            // APPEND's position is the file's end at once; WRITE's and APPEND's bytes are not read.
+            if (at.mode === "append") {
+                fill(this, host?.read?.(at.path) ?? EMPTY);
+            }
+            s.loads.deferHostEvent(() => {
+                if (this.$generation !== generation) {
+                    return;
+                }
+                const made = make(at.path, at.mode);
+                if (typeof made === "number") {
+                    failed(made);
+                }
+                else if (at.mode === "update") {
+                    deliver(this, made, generation, () => {
+                        this.$made = true;
+                        if (flush(this)) {
+                            outputProgress(this);
+                        }
+                    });
+                }
+                else {
+                    this.$made = true;
+                    if (flush(this)) {
+                        outputProgress(this);
+                    }
+                }
+            });
+        }
+        close() {
+            if (!this.$buffer) {
+                return;
+            }
+            // A file an asynchronous open had yet to make, or to read in, is made
+            // now to take what was written, around what it held.
+            if (!this.$made && this.$mode !== "read") {
+                const before = make(this.$path, this.$mode);
+                if (typeof before !== "number") {
+                    if (this.$mode === "update") {
+                        merge(this, before, 0);
+                    }
+                    this.$made = true;
+                }
+            }
+            const wrote = shut(this);
+            // An asynchronous stream says so on a later frame; a synchronous one says nothing.
+            if (this.$async) {
+                const generation = this.$generation;
+                s.loads.deferHostEvent(() => {
+                    if (this.$generation === generation) {
+                        if (wrote) {
+                            outputProgress(this);
+                        }
+                        event(this, s.event("close"));
+                    }
+                });
+            }
+        }
+        truncate() {
+            const buffer = writing(this);
+            const bytes = avm2.bytesOf(s.rt, buffer);
+            const at = bytes.position;
+            s.rt.setProperty(buffer, s.rt.publicName("length"), at);
+            changed(this, at, at);
+            // The file is cut at once, as adl's is, with what was written before.
+            flush(this);
+        }
+        get position() {
+            return avm2.bytesOf(s.rt, opened(this)).position;
+        }
+        set position(value) {
+            const bytes = avm2.bytesOf(s.rt, opened(this));
+            // APPEND writes at the end alone.
+            if (this.$mode === "append") {
+                throw s.rt.error("flash.errors::IllegalOperationError", 2037);
+            }
+            // As ByteArray's setter: a uint32 of its own, not toUint's (see Bytes).
+            bytes.position = s.rt.toUint(value) >>> 0;
+        }
+        get bytesAvailable() {
+            return avm2.bytesOf(s.rt, reading(this)).available;
+        }
+        get readAhead() {
+            return this.$readAhead ?? Number.POSITIVE_INFINITY;
+        }
+        set readAhead(value) {
+            this.$readAhead = s.rt.toNumber(value);
+        }
+        get endian() {
+            return this.$buffer
+                ? s.rt.getProperty(this.$buffer, s.rt.publicName("endian"))
+                : (this.$endian ?? "bigEndian");
+        }
+        set endian(value) {
+            // The buffer's setter checks it; the stream keeps it for the files it opens next.
+            if (this.$buffer) {
+                s.rt.setProperty(this.$buffer, s.rt.publicName("endian"), value);
+            }
+            this.$endian = this.$buffer
+                ? s.rt.getProperty(this.$buffer, s.rt.publicName("endian"))
+                : value;
+        }
+        get objectEncoding() {
+            return this.$buffer
+                ? s.rt.getProperty(this.$buffer, s.rt.publicName("objectEncoding"))
+                : (this.$objectEncoding ?? 3);
+        }
+        set objectEncoding(value) {
+            if (this.$buffer) {
+                s.rt.setProperty(this.$buffer, s.rt.publicName("objectEncoding"), value);
+            }
+            this.$objectEncoding = this.$buffer
+                ? s.rt.getProperty(this.$buffer, s.rt.publicName("objectEncoding"))
+                : value;
+        }
+        readBytes(bytes, offset = 0, length = 0) {
+            read(this, "readBytes", bytes, offset, length);
+        }
+        readBoolean() {
+            return read(this, "readBoolean");
+        }
+        readByte() {
+            return read(this, "readByte");
+        }
+        readUnsignedByte() {
+            return read(this, "readUnsignedByte");
+        }
+        readShort() {
+            return read(this, "readShort");
+        }
+        readUnsignedShort() {
+            return read(this, "readUnsignedShort");
+        }
+        readInt() {
+            return read(this, "readInt");
+        }
+        readUnsignedInt() {
+            return read(this, "readUnsignedInt");
+        }
+        readFloat() {
+            return read(this, "readFloat");
+        }
+        readDouble() {
+            return read(this, "readDouble");
+        }
+        readUTF() {
+            return read(this, "readUTF");
+        }
+        readUTFBytes(length) {
+            return read(this, "readUTFBytes", length);
+        }
+        readMultiByte(length, charset) {
+            return read(this, "readMultiByte", length, charset);
+        }
+        readObject() {
+            return read(this, "readObject");
+        }
+        writeBoolean(...args) {
+            write(this, "writeBoolean", ...args);
+        }
+        writeByte(...args) {
+            write(this, "writeByte", ...args);
+        }
+        writeBytes(...args) {
+            write(this, "writeBytes", ...args);
+        }
+        writeDouble(...args) {
+            write(this, "writeDouble", ...args);
+        }
+        writeFloat(...args) {
+            write(this, "writeFloat", ...args);
+        }
+        writeInt(...args) {
+            write(this, "writeInt", ...args);
+        }
+        writeMultiByte(...args) {
+            write(this, "writeMultiByte", ...args);
+        }
+        writeObject(...args) {
+            write(this, "writeObject", ...args);
+        }
+        writeShort(...args) {
+            write(this, "writeShort", ...args);
+        }
+        writeUnsignedInt(...args) {
+            write(this, "writeUnsignedInt", ...args);
+        }
+        writeUTF(...args) {
+            write(this, "writeUTF", ...args);
+        }
+        writeUTFBytes(...args) {
+            write(this, "writeUTFBytes", ...args);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.filesystem::FileStream", FileStreamNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/filesystem/paths.js

@@ -0,0 +1,156 @@
+// flash.filesystem.File's paths as AIR has them: native paths of the
+// host's system, POSIX or Windows by its separator, absolute alone, and
+// the URLs that name them: file: for any, app: and app-storage: for those
+// under the application's directory and its storage. A URL encodes each
+// segment of the path as UTF-8, as adl does (a space as %20, "#" as %23).
+export class NativePaths {
+    separator;
+    constructor(
+    /** The host's separator: "/", or "\\" on Windows. */
+    separator) {
+        this.separator = separator;
+    }
+    get windows() {
+        return this.separator === "\\";
+    }
+    /** A path's root and the segments under it; null where it is not absolute. */
+    split(path) {
+        if (this.windows) {
+            const drive = /^([A-Za-z]:)[\\/]?/.exec(path);
+            if (drive) {
+                return {
+                    root: `${drive[1].toUpperCase()}\\`,
+                    segments: this.segments(path.slice(drive[0].length)),
+                };
+            }
+            const unc = /^[\\/]{2}([^\\/]+)[\\/]+([^\\/]+)[\\/]?/.exec(path);
+            return unc
+                ? { root: `\\\\${unc[1]}\\${unc[2]}\\`, segments: this.segments(path.slice(unc[0].length)) }
+                : null;
+        }
+        return path.startsWith("/") ? { root: "/", segments: this.segments(path.slice(1)) } : null;
+    }
+    /**
+     * `rest`'s segments after `under`'s, its "." left out and each ".."
+     * taking the one before, but none of the first `floor`.
+     */
+    segments(rest, under = [], floor = 0) {
+        const out = [...under];
+        for (const segment of rest.split(this.windows ? /[\\/]/ : "/")) {
+            if (segment === "" || segment === ".") {
+                continue;
+            }
+            if (segment === "..") {
+                if (out.length > floor) {
+                    out.pop();
+                }
+            }
+            else {
+                out.push(segment);
+            }
+        }
+        return out;
+    }
+    isAbsolute(path) {
+        return this.split(path) !== null;
+    }
+    /** An absolute path in its plain form: one separator between segments, no "." or "..". */
+    normalize(path) {
+        const parts = this.split(path);
+        return parts ? parts.root + parts.segments.join(this.separator) : null;
+    }
+    /**
+     * `relative` resolved against `base`, an absolute path: an absolute
+     * `relative` stands alone; a relative one never goes above `floor`,
+     * where the File's URL starts, as adl keeps app:/'s ".." at app:/.
+     */
+    resolve(base, relative, floor) {
+        if (this.isAbsolute(relative)) {
+            return this.normalize(relative);
+        }
+        const parts = this.split(base);
+        // A path never climbs out of app:/ or app-storage:/.
+        const depth = floor ? (this.split(floor)?.segments.length ?? 0) : 0;
+        return parts.root + this.segments(relative, parts.segments, depth).join(this.separator);
+    }
+    /** The directory `path` is in; null for a root. */
+    parent(path) {
+        const parts = this.split(path);
+        if (!parts || parts.segments.length === 0) {
+            return null;
+        }
+        return parts.root + parts.segments.slice(0, -1).join(this.separator);
+    }
+    /** Its last segment, or for a root the root. */
+    name(path) {
+        const parts = this.split(path);
+        return parts && parts.segments.length > 0 ? parts.segments.at(-1) : path;
+    }
+    /** `path`'s segments under `under`, an ancestor or itself; null where it is not under it. */
+    under(path, under) {
+        const a = this.split(path);
+        const b = this.split(under);
+        if (!a || !b || !this.same(a.root, b.root) || a.segments.length < b.segments.length) {
+            return null;
+        }
+        for (let i = 0; i < b.segments.length; i++) {
+            if (!this.same(a.segments[i], b.segments[i])) {
+                return null;
+            }
+        }
+        return a.segments.slice(b.segments.length);
+    }
+    /** Whether two names are one, as Windows' file system takes letters' case as one. */
+    same(a, b) {
+        return this.windows ? a.toLowerCase() === b.toLowerCase() : a === b;
+    }
+    /** `path`'s file: URL, its segments encoded. */
+    fileUrl(path) {
+        const parts = this.split(path);
+        const encoded = parts.segments.map(encodeSegment).join("/");
+        if (this.windows) {
+            // file:///Z:/... for a drive, file://server/share/... for a share.
+            const unc = /^\\\\([^\\]+)\\([^\\]+)\\$/.exec(parts.root);
+            const head = unc
+                ? `file://${unc[1]}/${encodeSegment(unc[2])}/`
+                : `file:///${parts.root.slice(0, 2)}/`;
+            return head + encoded;
+        }
+        return `file:///${encoded}`;
+    }
+    /** The native path of a file: URL; null where it names none. */
+    fromFileUrl(url) {
+        const m = /^file:\/\/([^/]*)(\/.*)?$/i.exec(url);
+        if (!m) {
+            return null;
+        }
+        let decoded;
+        try {
+            decoded = decodeURIComponent(m[2] ?? "/");
+        }
+        catch {
+            return null;
+        }
+        if (this.windows) {
+            const path = m[1] ? `\\\\${m[1]}${decoded}` : decoded.replace(/^\/([A-Za-z]:)/, "$1");
+            return this.normalize(path.replaceAll("/", "\\"));
+        }
+        return m[1] ? null : this.normalize(decoded);
+    }
+    /** The segments of a URL's path under its root, decoded; null where one does not decode. */
+    urlSegments(rest) {
+        try {
+            return rest
+                .split("/")
+                .filter((s) => s !== "" && s !== ".")
+                .map(decodeURIComponent);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/** A path segment in a URL: UTF-8, percent-encoded as adl writes them ("#?%" and spaces among them). */
+export function encodeSegment(segment) {
+    return encodeURIComponent(segment);
+}