@swf2es/player-hosts 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,143 @@
+// What File and FileStream change on the host's file system, with the
+// errors adl (AIR 51.3, Windows) gives for them: a File of the app: URL
+// is never written (a SecurityError, by its URL alone: the same directory
+// through a file: URL or a native path is written), and the IOErrors say
+// what is in the way. A host without writing (FileSystemHost.write) is a
+// disk that refuses every write, IOError 3001.
+import { avm2 } from "../../../../runtime/index.js";
+import { NativePaths } from "./paths.js";
+/** "Error #id: message", as an IOErrorEvent's text begins. */
+export function errorText(id) {
+    return `Error #${id}: ${avm2.errorMessages[id]}`;
+}
+/** Throws adl's SecurityError where `at` is in the application's directory by its app: URL. */
+export function refuseApp(s, at) {
+    if (at.root === "app") {
+        throw s.rt.construct(s.rt.classNamed("SecurityError"), "fileWriteResource");
+    }
+}
+/** The host that writes: null for one that cannot. */
+function writer(s) {
+    const host = s.fileSystem;
+    return host?.write && host.createDirectory && host.remove
+        ? host
+        : null;
+}
+/**
+ * Why the file at `path` cannot be opened to write: 3006 for a directory,
+ * 3003 where a directory it is in is a file, 3001 for a host that does not
+ * write; 0 where it can be.
+ */
+export function openRefusal(s, path) {
+    const host = s.fileSystem;
+    if (host?.stat(path)?.directory) {
+        return 3006;
+    }
+    const paths = new NativePaths(host?.separator ?? "/");
+    for (let up = paths.parent(path); up !== null; up = paths.parent(up)) {
+        const stat = host?.stat(up);
+        if (stat) {
+            if (!stat.directory) {
+                return 3003;
+            }
+            break;
+        }
+    }
+    return writer(s) ? 0 : 3001;
+}
+/** Writes `bytes` at `offset` of `path`, which is then `length` long; false where the host cannot. */
+export function writeFile(s, path, bytes, offset, length) {
+    return writer(s)?.write(path, bytes, offset, length) ?? false;
+}
+/** File's createDirectory: 3002 for a file there; 0 once the directory is there. */
+export function createDirectory(s, path) {
+    const stat = s.fileSystem?.stat(path);
+    if (stat) {
+        return stat.directory ? 0 : 3002;
+    }
+    return writer(s)?.createDirectory(path) ? 0 : 3001;
+}
+/** File's deleteFile: 3003 for nothing there, 3001 for a directory; 0 once it is gone. */
+export function deleteFile(s, path) {
+    const stat = s.fileSystem?.stat(path);
+    if (!stat) {
+        return 3003;
+    }
+    if (stat.directory) {
+        return 3001;
+    }
+    return writer(s)?.remove(path) ? 0 : 3001;
+}
+/**
+ * File's deleteDirectory: 3003 for nothing there, 3007 for a file, 3010
+ * for one with something in it unless `contents` go too; 0 once it is gone.
+ */
+export function deleteDirectory(s, path, contents) {
+    const host = s.fileSystem;
+    const stat = host?.stat(path);
+    if (!stat) {
+        return 3003;
+    }
+    if (!stat.directory) {
+        return 3007;
+    }
+    if (!contents && (host?.list(path)?.length ?? 0) > 0) {
+        return 3010;
+    }
+    return writer(s)?.remove(path) ? 0 : 3001;
+}
+/**
+ * File's copyTo, and moveTo where `move`: 3003 for nothing at `from`, 3014
+ * where `to` is it or a directory it is in or under it, 3012 for something
+ * at `to` that may not be replaced (or cannot be removed); a directory is
+ * copied with all in it, and `to`'s directories are made. 0 once done.
+ */
+export function copyOrMove(s, from, to, overwrite, move) {
+    const host = s.fileSystem;
+    const paths = new NativePaths(host?.separator ?? "/");
+    if (!host?.stat(from)) {
+        return 3003;
+    }
+    if (paths.under(to, from) || paths.under(from, to)) {
+        return 3014;
+    }
+    const write = writer(s);
+    if (host.stat(to)) {
+        if (!overwrite || !write?.remove(to)) {
+            return 3012;
+        }
+    }
+    if (!write) {
+        return 3001;
+    }
+    if (move && host.move) {
+        return host.move(from, to) ? 0 : 3001;
+    }
+    if (!copy(host, write, paths, from, to)) {
+        return 3001;
+    }
+    return !move || write.remove(from) ? 0 : 3001;
+}
+function copy(host, write, paths, from, to) {
+    const stat = host.stat(from);
+    if (!stat) {
+        return false;
+    }
+    if (!stat.directory) {
+        const bytes = host.read?.(from);
+        return !!bytes && write.write(to, bytes, 0, bytes.length);
+    }
+    if (!write.createDirectory(to)) {
+        return false;
+    }
+    for (const name of host.list(from) ?? []) {
+        if (!copy(host, write, paths, paths.resolve(from, name, null), paths.resolve(to, name, null))) {
+            return false;
+        }
+    }
+    return true;
+}
+/** An IOErrorEvent of `id`, its text adl's: "Error #id: message", and `suffix`. */
+export function ioErrorEvent(s, id, suffix = "") {
+    return s.rt.construct(s.rt.classNamed("flash.events::IOErrorEvent"), "ioError", false, false, `${errorText(id)}${suffix}`, id);
+}

package/dist/thread/player/playerglobal/flash/filters/BevelFilter.js

@@ -0,0 +1,4 @@
+import { filterNatives } from "./BitmapFilter.js";
+export function bevelFilterNatives(s) {
+    return filterNatives(s, "bevel");
+}

package/dist/thread/player/playerglobal/flash/filters/BitmapFilter.js

@@ -0,0 +1,205 @@
+// flash.filters.BitmapFilter, and what its subclasses share: each keeps its
+// values as adl converts them, in a record (`$filter`) that
+// DisplayObject.filters copies to and from the display object's
+// (display/filters.ts in the player), so a filter read back is a copy.
+import { avm2 } from "../../../../runtime/index.js";
+import { filterDefaults } from "../../../display/filters.js";
+const CLASSES = [
+    ["BlurFilter", "blur"],
+    ["GlowFilter", "glow"],
+    ["DropShadowFilter", "dropShadow"],
+    ["BevelFilter", "bevel"],
+    ["GradientGlowFilter", "gradientGlow"],
+    ["GradientBevelFilter", "gradientBevel"],
+    ["ColorMatrixFilter", "colorMatrix"],
+    ["ConvolutionFilter", "convolution"],
+    ["DisplacementMapFilter", "displacementMap"],
+    ["ShaderFilter", "shader"],
+];
+/** A filter object's class by kind, for the objects a display object's filters are read back as. */
+export function filterClassName(kind) {
+    return `flash.filters::${CLASSES.find(([, k]) => k === kind)?.[0]}`;
+}
+/** The kind of a filter object, by its class or a base of it: null for one that is no filter swf2es knows. */
+export function filterKindOf(rt, o) {
+    for (let t = rt.traitsOf(o); t; t = t.base) {
+        const found = CLASSES.find(([name]) => t.name === `flash.filters::${name}`);
+        if (found) {
+            return found[1];
+        }
+    }
+    return null;
+}
+/** The record of a filter object, made with the kind's defaults when first touched. */
+export function recordOf(o, kind) {
+    o.$filter ??= filterDefaults(kind);
+    return o.$filter;
+}
+/** The conversions of filters' values as adl keeps them: alpha in 255ths, strength in 256ths, clamped. */
+function filterValues(s) {
+    const num = (v) => s.rt.toNumber(v);
+    const blur = (v) => {
+        const n = num(v);
+        return Number.isNaN(n) ? n : Math.max(0, Math.min(255, n));
+    };
+    const quality = (v) => Math.max(0, Math.min(15, s.rt.toInt(v)));
+    const alpha = (v) => {
+        const n = num(v);
+        return Number.isNaN(n) ? 0 : Math.trunc(Math.max(0, Math.min(1, n)) * 255) / 255;
+    };
+    const color = (v) => s.rt.toUint(v) & 0xffffff;
+    // 8.8 fixed point, converted as x87 converts: past an int's range it is the indefinite, 0 once clamped.
+    const strength = (v) => {
+        const fixed = Math.trunc(num(v) * 256);
+        return Number.isFinite(fixed) && Math.abs(fixed) < 2 ** 31
+            ? Math.max(0, Math.min(255 * 256, fixed)) / 256
+            : 0;
+    };
+    // Within a turn either way, through radians and back, left to right as
+    // adl's arithmetic goes: 300 is 300.00000000000006.
+    const angle = (v) => ((((num(v) % 360) * Math.PI) / 180) * 180) / Math.PI;
+    const type = (v) => {
+        if (v === null || v === undefined) {
+            throw s.rt.error("TypeError", 2007, "type");
+        }
+        const t = s.rt.toString(v);
+        return t === "inner" || t === "outer" ? t : "full";
+    };
+    /** An int through x87's conversion: out of int32's range it is the indefinite, 0 once clamped. */
+    const matrixSize = (v) => {
+        const n = Math.trunc(num(v));
+        return Number.isFinite(n) && Math.abs(n) < 2 ** 31 ? Math.max(0, Math.min(15, n)) : 0;
+    };
+    const elements = (v, name) => {
+        if (v === null || v === undefined) {
+            throw s.rt.error("TypeError", 2007, name);
+        }
+        return v.$a ?? [];
+    };
+    // A hole is 0, as a missing value is; an undefined one is NaN.
+    const floats = (values, length) => Array.from({ length }, (_, i) => (i in values ? Math.fround(num(values[i])) : 0));
+    /** The conversion of each value every kind that has it keeps alike, by its record's key. */
+    const converts = {
+        blurX: blur,
+        blurY: blur,
+        quality,
+        alpha,
+        color,
+        strength,
+        angle,
+        distance: num,
+        inner: Boolean,
+        knockout: Boolean,
+        hideObject: Boolean,
+        highlightColor: color,
+        highlightAlpha: alpha,
+        shadowColor: color,
+        shadowAlpha: alpha,
+        type,
+        divisor: (v) => Math.fround(num(v)),
+        bias: (v) => Math.fround(num(v)),
+        clamp: Boolean,
+        preserveAlpha: Boolean,
+        componentX: (v) => s.rt.toUint(v),
+        componentY: (v) => s.rt.toUint(v),
+        scaleX: (v) => scale(v),
+        scaleY: (v) => scale(v),
+    };
+    const props = Object.fromEntries(Object.entries(converts).map(([key, convert]) => [
+        key,
+        [
+            (f) => f[key],
+            (f, v) => {
+                f[key] = convert(v);
+            },
+        ],
+    ]));
+    function scale(v) {
+        const n = num(v);
+        return Number.isNaN(n) ? n : Math.fround(Math.max(-65535, Math.min(65535, n)));
+    }
+    /**
+     * A gradient's stops, at most 16, as adl keeps them: colours set their
+     * count, padding alphas and ratios with 0; alphas fill to it, padding
+     * with 1; ratios, truncated and clamped, can only make it fewer.
+     */
+    function gradientProps() {
+        return {
+            colors: [
+                (f) => s.rt.array([...f.colors]),
+                (f, v) => {
+                    // A hole reads as undefined, colour 0, where map would skip it.
+                    const values = elements(v, "colors");
+                    f.colors = Array.from({ length: Math.min(16, values.length) }, (_, i) => color(values[i]));
+                    const n = f.colors.length;
+                    f.alphas = Array.from({ length: n }, (_, i) => f.alphas[i] ?? 0);
+                    f.ratios = Array.from({ length: n }, (_, i) => f.ratios[i] ?? 0);
+                },
+            ],
+            alphas: [
+                (f) => s.rt.array([...f.alphas]),
+                (f, v) => {
+                    const values = elements(v, "alphas");
+                    f.alphas = Array.from({ length: f.colors.length }, (_, i) => i < values.length ? alpha(values[i]) : 1);
+                },
+            ],
+            ratios: [
+                (f) => s.rt.array([...f.ratios]),
+                (f, v) => {
+                    const values = elements(v, "ratios");
+                    const n = Math.min(f.colors.length, values.length);
+                    f.colors.length = n;
+                    f.alphas.length = n;
+                    f.ratios = Array.from({ length: n }, (_, i) => {
+                        const x = Math.trunc(num(values[i]));
+                        return Number.isNaN(x) ? 0 : Math.max(0, Math.min(255, x));
+                    });
+                },
+            ],
+        };
+    }
+    return { num, alpha, color, matrixSize, elements, floats, props, gradientProps };
+}
+/** A filter class's natives: its kind's record's properties of `props`, and its `own`. */
+export function filterNatives(s, kind, own = () => ({})) {
+    const natives = {};
+    const values = filterValues(s);
+    const { props } = values;
+    const name = filterClassName(kind).slice("flash.filters::".length);
+    const defaults = filterDefaults(kind);
+    const members = {};
+    const all = {
+        ...Object.fromEntries(Object.keys(props)
+            .filter((k) => k in defaults)
+            .map((k) => [k, props[k]])),
+        ...own(values),
+    };
+    for (const [key, [get, set]] of Object.entries(all)) {
+        members[key] = {
+            get() {
+                return get(recordOf(this, kind));
+            },
+            set(v) {
+                set(recordOf(this, kind), v);
+            },
+        };
+    }
+    const cls = class {
+    };
+    Object.defineProperties(cls.prototype, members);
+    avm2.registerNativeClass(natives, `flash.filters::${name}`, cls);
+    return natives;
+}
+/**
+ * BitmapFilter, as adl has it: abstract, and restricted, so that only
+ * playerglobal's own filters, and what extends them, are made; a script's
+ * class extending it is refused as it is.
+ */
+export const bitmapFilterHooks = {
+    "flash.filters::BitmapFilter": {
+        construct: (rt) => {
+            throw rt.error("ArgumentError", 2012, "BitmapFilter$");
+        },
+        restricted: true,
+    },
+};

package/dist/thread/player/playerglobal/flash/filters/BlurFilter.js

@@ -0,0 +1,4 @@
+import { filterNatives } from "./BitmapFilter.js";
+export function blurFilterNatives(s) {
+    return filterNatives(s, "blur");
+}

package/dist/thread/player/playerglobal/flash/filters/ColorMatrixFilter.js

@@ -0,0 +1,11 @@
+import { filterNatives } from "./BitmapFilter.js";
+export function colorMatrixFilterNatives(s) {
+    return filterNatives(s, "colorMatrix", ({ elements, floats }) => ({
+        matrix: [
+            (f) => s.rt.array([...f.matrix]),
+            (f, v) => {
+                f.matrix = floats(elements(v, "matrix"), 20);
+            },
+        ],
+    }));
+}

package/dist/thread/player/playerglobal/flash/filters/ConvolutionFilter.js

@@ -0,0 +1,26 @@
+import { filterNatives } from "./BitmapFilter.js";
+export function convolutionFilterNatives(s) {
+    return filterNatives(s, "convolution", ({ elements, floats, matrixSize }) => ({
+        matrix: [
+            (f) => s.rt.array([...f.matrix]),
+            (f, v) => {
+                f.matrix = floats(elements(v, "matrix"), f.matrixX * f.matrixY);
+            },
+        ],
+        // Resized, the flat values stay in order, as many as fit, the rest 0.
+        matrixX: [
+            (f) => f.matrixX,
+            (f, v) => {
+                f.matrixX = matrixSize(v);
+                f.matrix = floats(f.matrix, f.matrixX * f.matrixY);
+            },
+        ],
+        matrixY: [
+            (f) => f.matrixY,
+            (f, v) => {
+                f.matrixY = matrixSize(v);
+                f.matrix = floats(f.matrix, f.matrixX * f.matrixY);
+            },
+        ],
+    }));
+}

package/dist/thread/player/playerglobal/flash/filters/DisplacementMapFilter.js

@@ -0,0 +1,51 @@
+import { filterNatives } from "./BitmapFilter.js";
+/**
+ * A copy of a displacement map's BitmapData, made as Flash makes it: a
+ * plain BitmapData of the same pixels, not through the object's own
+ * clone, which a script may override. Null for none, or one disposed.
+ */
+export function copyMap(s, map) {
+    const store = map?.$store;
+    if (!store || store.disposed) {
+        return null;
+    }
+    const o = s.rt.construct(s.rt.classNamed("flash.display::BitmapData"), store.width, store.height, store.transparent, 0);
+    o.$store = store.clone();
+    return o;
+}
+export function displacementMapFilterNatives(s) {
+    return filterNatives(s, "displacementMap", ({ num }) => ({
+        // A copy each way, as adl gives one: the map's pixels, the point in whole pixels.
+        mapBitmap: [
+            (f) => copyMap(s, f.mapBitmap),
+            (f, v) => {
+                f.mapBitmap = v ?? null;
+            },
+        ],
+        mapPoint: [
+            (f) => s.rt.construct(s.rt.classNamed("flash.geom::Point"), f.mapPoint[0], f.mapPoint[1]),
+            (f, v) => {
+                const p = v;
+                f.mapPoint = p
+                    ? [
+                        Math.trunc(num(s.rt.getProperty(p, s.rt.publicName("x")))) || 0,
+                        Math.trunc(num(s.rt.getProperty(p, s.rt.publicName("y")))) || 0,
+                    ]
+                    : [0, 0];
+            },
+        ],
+        mode: [
+            (f) => f.mode,
+            (f, v) => {
+                if (v === null || v === undefined) {
+                    throw s.rt.error("TypeError", 2007, "mode");
+                }
+                const mode = s.rt.toString(v);
+                if (!["wrap", "clamp", "ignore", "color"].includes(mode)) {
+                    throw s.rt.error("ArgumentError", 2008, "mode");
+                }
+                f.mode = mode;
+            },
+        ],
+    }));
+}

package/dist/thread/player/playerglobal/flash/filters/DropShadowFilter.js

@@ -0,0 +1,4 @@
+import { filterNatives } from "./BitmapFilter.js";
+export function dropShadowFilterNatives(s) {
+    return filterNatives(s, "dropShadow");
+}

package/dist/thread/player/playerglobal/flash/filters/GlowFilter.js

@@ -0,0 +1,4 @@
+import { filterNatives } from "./BitmapFilter.js";
+export function glowFilterNatives(s) {
+    return filterNatives(s, "glow");
+}

package/dist/thread/player/playerglobal/flash/filters/GradientBevelFilter.js

@@ -0,0 +1,4 @@
+import { filterNatives } from "./BitmapFilter.js";
+export function gradientBevelFilterNatives(s) {
+    return filterNatives(s, "gradientBevel", ({ gradientProps }) => gradientProps());
+}

package/dist/thread/player/playerglobal/flash/filters/GradientGlowFilter.js

@@ -0,0 +1,4 @@
+import { filterNatives } from "./BitmapFilter.js";
+export function gradientGlowFilterNatives(s) {
+    return filterNatives(s, "gradientGlow", ({ gradientProps }) => gradientProps());
+}

package/dist/thread/player/playerglobal/flash/filters/ShaderFilter.js

@@ -0,0 +1,53 @@
+import { kernelOfShader } from "../display/shaders.js";
+import { filterNatives } from "./BitmapFilter.js";
+export function shaderFilterNatives(s) {
+    const extension = (v) => {
+        const n = s.rt.toInt(v);
+        if (n < 0) {
+            throw s.rt.error("RangeError", 2006);
+        }
+        return n;
+    };
+    const side = (k) => [
+        (f) => f.extensions[k],
+        (f, v) => {
+            f.extensions[k] = extension(v);
+        },
+    ];
+    return filterNatives(s, "shader", () => ({
+        shader: [
+            (f) => f.shader ?? null,
+            (f, v) => {
+                if (v === null || v === undefined) {
+                    throw s.rt.error("TypeError", 2007, "shader");
+                }
+                if (!kernelOfShader(v)) {
+                    throw s.rt.error("ArgumentError", 2171);
+                }
+                f.shader = v;
+            },
+        ],
+        leftExtension: side(0),
+        topExtension: side(1),
+        rightExtension: side(2),
+        bottomExtension: side(3),
+        "flash.filters:ShaderFilter::_extendBy": [
+            (f) => {
+                const [left, top, right, bottom] = f.extensions;
+                return s.rt.construct(s.rt.classNamed("flash.geom::Rectangle"), left, top, right - left, bottom - top);
+            },
+            (f, v) => {
+                if (v === null || v === undefined) {
+                    throw s.rt.error("TypeError", 2007, "extendBy");
+                }
+                const read = (k) => s.rt.getProperty(v, s.rt.publicName(k));
+                f.extensions = [
+                    extension(read("left")),
+                    extension(read("top")),
+                    extension(read("right")),
+                    extension(read("bottom")),
+                ];
+            },
+        ],
+    }));
+}