@swf2es/player 0.0.0-stage → 0.1.1

package/src/playerglobal/flash/filesystem/paths.ts

@@ -0,0 +1,181 @@
+// 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).
+
+/** Where a File's URL starts: the file system's root, the application's directory or its storage's. */
+export type Root = "file" | "app" | "app-storage";
+
+export class NativePaths {
+  constructor(
+    /** The host's separator: "/", or "\\" on Windows. */
+    readonly separator: string,
+  ) {}
+
+  private get windows(): boolean {
+    return this.separator === "\\";
+  }
+
+  /** A path's root and the segments under it; null where it is not absolute. */
+  private split(path: string): { root: string; segments: string[] } | null {
+    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`.
+   */
+  private segments(rest: string, under: string[] = [], floor = 0): string[] {
+    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: string): boolean {
+    return this.split(path) !== null;
+  }
+
+  /** An absolute path in its plain form: one separator between segments, no "." or "..". */
+  normalize(path: string): string | null {
+    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: string, relative: string, floor: string | null): string {
+    if (this.isAbsolute(relative)) {
+      return this.normalize(relative) as string;
+    }
+
+    const parts = this.split(base) as { root: string; segments: string[] };
+    // 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: string): string | null {
+    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: string): string {
+    const parts = this.split(path);
+    return parts && parts.segments.length > 0 ? (parts.segments.at(-1) as string) : path;
+  }
+
+  /** `path`'s segments under `under`, an ancestor or itself; null where it is not under it. */
+  under(path: string, under: string): string[] | null {
+    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. */
+  private same(a: string, b: string): boolean {
+    return this.windows ? a.toLowerCase() === b.toLowerCase() : a === b;
+  }
+
+  /** `path`'s file: URL, its segments encoded. */
+  fileUrl(path: string): string {
+    const parts = this.split(path) as { root: string; segments: string[] };
+    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: string): string | null {
+    const m = /^file:\/\/([^/]*)(\/.*)?$/i.exec(url);
+    if (!m) {
+      return null;
+    }
+
+    let decoded: string;
+    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: string): string[] | null {
+    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: string): string {
+  return encodeURIComponent(segment);
+}

package/src/playerglobal/flash/filesystem/writes.ts

@@ -0,0 +1,203 @@
+// 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 "@swf2es/runtime";
+import type { FileSystemHost } from "../../../hosts.js";
+import type { Scripting } from "../../../scripting.js";
+import type { FileLocation } from "./File.js";
+import { NativePaths } from "./paths.js";
+
+type AsObject = avm2.AsObject;
+
+/** "Error #id: message", as an IOErrorEvent's text begins. */
+export function errorText(id: number): string {
+  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: Scripting, at: FileLocation): void {
+  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: Scripting): Required<FileSystemHost> | null {
+  const host = s.fileSystem;
+  return host?.write && host.createDirectory && host.remove
+    ? (host as Required<FileSystemHost>)
+    : 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: Scripting, path: string): number {
+  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: Scripting,
+  path: string,
+  bytes: Uint8Array,
+  offset: number,
+  length: number,
+): boolean {
+  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: Scripting, path: string): number {
+  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: Scripting, path: string): number {
+  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: Scripting, path: string, contents: boolean): number {
+  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: Scripting,
+  from: string,
+  to: string,
+  overwrite: boolean,
+  move: boolean,
+): number {
+  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: FileSystemHost,
+  write: Required<FileSystemHost>,
+  paths: NativePaths,
+  from: string,
+  to: string,
+): boolean {
+  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: Scripting, id: number, suffix = ""): AsObject {
+  return s.rt.construct(
+    s.rt.classNamed("flash.events::IOErrorEvent"),
+    "ioError",
+    false,
+    false,
+    `${errorText(id)}${suffix}`,
+    id,
+  ) as AsObject;
+}

package/src/playerglobal/flash/filters/BevelFilter.ts

@@ -0,0 +1,9 @@
+// flash.filters.BevelFilter: a highlight and a shadow at a distance and
+// angle, kept as adl converts them.
+import type { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import { filterNatives } from "./BitmapFilter.js";
+
+export function bevelFilterNatives(s: Scripting): avm2.Natives {
+  return filterNatives(s, "bevel");
+}

package/src/playerglobal/flash/filters/BitmapFilter.ts

@@ -0,0 +1,237 @@
+// 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 "@swf2es/runtime";
+import { type Filter, type FilterKind, filterDefaults } from "../../../display/filters.js";
+import type { Scripting } from "../../../scripting.js";
+
+type AsObject = avm2.AsObject;
+type Value = avm2.Value;
+
+export type Prop = [get: (f: Filter) => Value, set: (f: Filter, v: Value) => void];
+
+const CLASSES: [string, FilterKind][] = [
+  ["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: FilterKind): string {
+  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: avm2.Runtime, o: AsObject): FilterKind | null {
+  for (let t: ReturnType<avm2.Runtime["traitsOf"]> | null = 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: AsObject, kind: FilterKind): Filter {
+  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: Scripting) {
+  const num = (v: Value) => s.rt.toNumber(v);
+  const blur = (v: Value) => {
+    const n = num(v);
+    return Number.isNaN(n) ? n : Math.max(0, Math.min(255, n));
+  };
+  const quality = (v: Value) => Math.max(0, Math.min(15, s.rt.toInt(v)));
+  const alpha = (v: Value) => {
+    const n = num(v);
+    return Number.isNaN(n) ? 0 : Math.trunc(Math.max(0, Math.min(1, n)) * 255) / 255;
+  };
+  const color = (v: Value) => 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: Value) => {
+    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: Value) => ((((num(v) % 360) * Math.PI) / 180) * 180) / Math.PI;
+  const type = (v: Value) => {
+    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: Value) => {
+    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: Value, name: string): Value[] => {
+    if (v === null || v === undefined) {
+      throw s.rt.error("TypeError", 2007, name);
+    }
+
+    return ((v as AsObject).$a as Value[] | undefined) ?? [];
+  };
+  // A hole is 0, as a missing value is; an undefined one is NaN.
+  const floats = (values: Value[], length: number): number[] =>
+    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: Record<string, (v: Value) => unknown> = {
+    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: Record<string, Prop> = Object.fromEntries(
+    Object.entries(converts).map(([key, convert]) => [
+      key,
+      [
+        (f: Filter) => (f as unknown as Record<string, Value>)[key],
+        (f: Filter, v: Value) => {
+          (f as unknown as Record<string, unknown>)[key] = convert(v);
+        },
+      ],
+    ]),
+  );
+  function scale(v: Value): number {
+    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(): Record<string, Prop> {
+    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: Scripting,
+  kind: FilterKind,
+  own: (values: ReturnType<typeof filterValues>) => Record<string, Prop> = () => ({}),
+): avm2.Natives {
+  const natives: avm2.Natives = {};
+  const values = filterValues(s);
+  const { props } = values;
+  const name = filterClassName(kind).slice("flash.filters::".length);
+  const defaults = filterDefaults(kind);
+  const members: Record<string, PropertyDescriptor> = {};
+  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(this: AsObject) {
+        return get(recordOf(this, kind));
+      },
+      set(this: AsObject, v: Value) {
+        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: Record<string, avm2.ClassHook> = {
+  "flash.filters::BitmapFilter": {
+    construct: (rt) => {
+      throw rt.error("ArgumentError", 2012, "BitmapFilter$");
+    },
+    restricted: true,
+  },
+};

package/src/playerglobal/flash/filters/BlurFilter.ts

@@ -0,0 +1,8 @@
+// flash.filters.BlurFilter: its blurs and quality, kept as adl converts them.
+import type { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import { filterNatives } from "./BitmapFilter.js";
+
+export function blurFilterNatives(s: Scripting): avm2.Natives {
+  return filterNatives(s, "blur");
+}

package/src/playerglobal/flash/filters/ColorMatrixFilter.ts

@@ -0,0 +1,15 @@
+// flash.filters.ColorMatrixFilter: its matrix, 20 floats.
+import type { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import { filterNatives } from "./BitmapFilter.js";
+
+export function colorMatrixFilterNatives(s: Scripting): avm2.Natives {
+  return filterNatives(s, "colorMatrix", ({ elements, floats }) => ({
+    matrix: [
+      (f) => s.rt.array([...f.matrix]),
+      (f, v) => {
+        f.matrix = floats(elements(v, "matrix"), 20);
+      },
+    ],
+  }));
+}

package/src/playerglobal/flash/filters/ConvolutionFilter.ts

@@ -0,0 +1,31 @@
+// flash.filters.ConvolutionFilter: its matrix and size, as floats and
+// whole numbers, and the rest of its values as adl converts them.
+import type { avm2 } from "@swf2es/runtime";
+import type { Scripting } from "../../../scripting.js";
+import { filterNatives } from "./BitmapFilter.js";
+
+export function convolutionFilterNatives(s: Scripting): avm2.Natives {
+  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);
+      },
+    ],
+  }));
+}