animl 0.0.0-stage → 0.1.0

package/modules/markup-libraries/markup/async.js

@@ -0,0 +1,35 @@
+import { compile } from "../../../packages/markup/src/compile.js";
+import { attr, importPath } from "./reuse.js";
+import { parseXml } from "../../../packages/markup/src/xml.js";
+async function compileLibrariesAsync(source, opts, compiler = compile) {
+  const cache = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set([opts.file ?? ""]);
+  const visit = async (text, file) => {
+    const root = parseXml(text).doc.root;
+    if (!root) return;
+    for (const el of root.children) {
+      if (el.kind !== "element" || el.name !== "import") continue;
+      const path = importPath(attr(el, "src"), file);
+      if (seen.has(path)) continue;
+      seen.add(path);
+      try {
+        const imported = await opts.resolve(path);
+        cache.set(path, imported);
+        await visit(imported, path);
+      } catch {
+      }
+    }
+  };
+  await visit(source, opts.file);
+  return compiler(source, {
+    ...opts,
+    resolve: (path) => {
+      const value = cache.get(path);
+      if (value === void 0) throw Error();
+      return value;
+    }
+  });
+}
+export {
+  compileLibrariesAsync
+};

package/modules/markup-libraries/markup/hooks.d.ts

@@ -0,0 +1,14 @@
+import type { CompileOptions, CompileResult, MarkupDiagnostic } from '../../../packages/markup/src/index.js';
+import type { XmlDocument, Pos } from '../../../packages/markup/src/xml.js';
+export type AsyncCompileOptions = Omit<CompileOptions, 'resolve'> & {
+    resolve: (path: string) => string | Promise<string>;
+};
+export declare const libraryCompiler: {
+    expand?: (xml: XmlDocument, opts: CompileOptions, diagnostics: MarkupDiagnostic[]) => void;
+    async?: (source: string, opts: AsyncCompileOptions, compiler?: (source: string, opts?: CompileOptions) => CompileResult) => Promise<CompileResult>;
+};
+export declare function location(at: Pos): {
+    file?: string;
+    line: number;
+    column: number;
+};

package/modules/markup-libraries/markup/hooks.js

@@ -0,0 +1,8 @@
+const libraryCompiler = {};
+function location(at) {
+  return { file: at.file, line: at.line, column: at.col };
+}
+export {
+  libraryCompiler,
+  location
+};

package/modules/markup-libraries/markup/index.d.ts

@@ -0,0 +1 @@
+export { importPath } from './reuse.js';

package/modules/markup-libraries/markup/index.js

@@ -0,0 +1,9 @@
+import { libraryCompiler } from "./hooks.js";
+import { expand } from "./reuse.js";
+import { compileLibrariesAsync } from "./async.js";
+libraryCompiler.expand = expand;
+libraryCompiler.async = compileLibrariesAsync;
+import { importPath } from "./reuse.js";
+export {
+  importPath
+};

package/modules/markup-libraries/markup/reuse.d.ts

@@ -0,0 +1,6 @@
+import type { CompileOptions, MarkupDiagnostic } from '../../../packages/markup/src/index.js';
+import { type Element, type XmlDocument } from '../../../packages/markup/src/xml.js';
+export declare const attr: (el: Element, name: string) => string;
+/** Host resolvers receive a normalised path relative to the importing file (or an absolute URL). */
+export declare function importPath(path: string, file?: string): string;
+export declare function expand(xml: XmlDocument, opts: CompileOptions, diagnostics: MarkupDiagnostic[]): void;

package/modules/markup-libraries/markup/reuse.js

@@ -0,0 +1,320 @@
+import { NAME, VERBOSE } from "animl";
+import {
+  escapeText,
+  parseXml
+} from "../../../packages/markup/src/xml.js";
+import { location } from "./hooks.js";
+const attr = (el, name) => el.attrs.find((a) => a.name === name)?.value ?? "";
+function importPath(path, file = "") {
+  if (/^[a-z]+:/i.test(file)) return new URL(path, file).href;
+  if (/^[a-z]+:/i.test(path)) return path;
+  const parts = [];
+  const joined = path.startsWith("/") ? path : file.slice(0, file.lastIndexOf("/") + 1) + path;
+  for (const part of joined.split("/")) {
+    if (part === ".." && parts.length && parts.at(-1) !== "..") parts.pop();
+    else if (part && part !== ".") parts.push(part);
+  }
+  return (joined.startsWith("/") ? "/" : "") + parts.join("/");
+}
+const declarations = [
+  "template",
+  "color",
+  "glyph",
+  "ease",
+  "component",
+  "model",
+  "enum",
+  "instance"
+];
+function expand(xml, opts, diagnostics) {
+  const resources = [];
+  const componentNames = {};
+  const active = /* @__PURE__ */ new Set([opts.file ?? ""]);
+  const root = xml.root;
+  const names = /* @__PURE__ */ new Set();
+  const scan = (el) => {
+    names.add(attr(el, "name"));
+    for (const c of el.children) if (c.kind === "element") scan(c);
+  };
+  scan(root);
+  let serial = 0;
+  const error = (code, at, message, related) => {
+    diagnostics.push({
+      code,
+      severity: "error",
+      pointer: "",
+      message: VERBOSE ? message : code,
+      file: at.file ?? opts.file,
+      line: at.line,
+      column: at.col,
+      ...related ?? at.related ? { related: relatedLocations(related ?? at.related) } : {},
+      ...VERBOSE ? { hint: "check the declaration and its import or apply site" } : {}
+    });
+  };
+  const annotate = (el, file, doc, related) => {
+    const mark = (at) => Object.assign(at, { file, related, locate: doc.pos });
+    mark(el.at);
+    for (const a of el.attrs) {
+      mark(a.at);
+      mark(a.valueAt);
+    }
+    for (const c of el.children) {
+      if (c.kind === "element") annotate(c, file, doc, related);
+      else mark(c.at);
+    }
+  };
+  const select = (scope2, el, alias) => {
+    const selected = (attr(el, "export") || attr(el, alias)).split(/\s+/).filter(Boolean);
+    for (const name of selected)
+      if (![...scope2.keys()].some((key) => key.split(" ")[1] === name))
+        error("unknown-name", el.at, VERBOSE ? `unknown library export ${name}` : "");
+    return selected.length ? new Map([...scope2].filter(([key]) => selected.includes(key.split(" ")[1]))) : scope2;
+  };
+  const scopeFor = (el, file, prefix = "") => {
+    const imported = !!prefix;
+    const scope2 = /* @__PURE__ */ new Map();
+    const aliases = /* @__PURE__ */ new Set();
+    for (const c of el.children) {
+      if (c.kind !== "element") continue;
+      if (c.name === "import") {
+        const src = attr(c, "src"), alias = attr(c, "as");
+        if (!src || !NAME.test(alias)) {
+          error("bad-attribute", c.at, VERBOSE ? "import needs src and a valid as name" : "");
+          continue;
+        }
+        if (aliases.has(alias))
+          error("duplicate-name", c.at, VERBOSE ? "duplicate import alias" : "");
+        aliases.add(alias);
+        const path = importPath(src, file);
+        if (active.has(path)) {
+          error("import-cycle", c.at, VERBOSE ? `import cycle at ${path}` : "");
+          continue;
+        }
+        let source;
+        try {
+          source = opts.resolve(path);
+        } catch {
+          error("unknown-import", c.at, VERBOSE ? `cannot read import ${path}` : "");
+          continue;
+        }
+        const parsed = parseXml(source);
+        for (const e of parsed.errors)
+          error("markup-syntax", { ...e.at, file: path }, e.message, c.at);
+        if (!parsed.doc.root) continue;
+        annotate(parsed.doc.root, path, parsed.doc, c.at);
+        if (parsed.doc.root.name !== "library") {
+          error(
+            "bad-import",
+            parsed.doc.root.at,
+            VERBOSE ? "imported root must be <library>" : "",
+            c.at
+          );
+          continue;
+        }
+        if (!NAME.test(attr(parsed.doc.root, "name")))
+          error(
+            "bad-attribute",
+            parsed.doc.root.at,
+            VERBOSE ? "library needs a valid name" : "",
+            c.at
+          );
+        active.add(path);
+        const exports = scopeFor(parsed.doc.root, path, prefix + alias + ":");
+        active.delete(path);
+        for (const [key, value] of select(exports, c, "select"))
+          scope2.set(key.replace(" ", ` ${alias}:`), value);
+      } else if (declarations.includes(c.name) && (c.name !== "instance" || attr(c, "model"))) {
+        const name = attr(c, "name");
+        const key = `${c.name} ${name}`;
+        if (!(["model", "enum"].includes(c.name) ? /^[a-zA-Z][\w-]*$/ : c.name === "component" ? /^[a-z][\w-]*(?::[a-z][\w-]*)*$/ : NAME).test(name))
+          error("bad-attribute", c.at, VERBOSE ? "declaration needs a valid name" : "");
+        if (scope2.has(key)) error("duplicate-name", c.at, VERBOSE ? `duplicate name ${name}` : "");
+        let output = name;
+        if (imported && c.name !== "template") {
+          do {
+            output = `import-${++serial}-${name}`;
+          } while (names.has(output));
+          names.add(output);
+          if (c.name === "component") output = prefix + name;
+        }
+        const d = { el: c, scope: scope2, name: output };
+        scope2.set(key, d);
+        if (imported && c.name !== "template") {
+          resources.push(d);
+        }
+      } else if (imported)
+        error("misplaced-element", c.at, VERBOSE ? `<${c.name}> is not allowed in a library` : "");
+    }
+    return imported ? select(scope2, el, "exports") : scope2;
+  };
+  const reference = (value, kind, scope2, at, quote = false) => {
+    const d = scope2.get(`${kind} ${value}`);
+    if (d) return quote ? JSON.stringify(d.name) : d.name;
+    if (/^[a-z][\w-]*:/.test(value))
+      error("unknown-name", at, VERBOSE ? `unknown ${kind} ${value}` : "");
+    return value;
+  };
+  const clone = (c, params, scope2, uses, track = false) => {
+    const subst = (s) => s.replace(/\{([a-z][\w-]*)\}/g, (all, key) => params[key] ?? all);
+    const origin = (at) => ({ ...at, ...uses.length ? { related: uses.at(-1) } : {} });
+    if (c.kind !== "element") {
+      if (c.kind === "comment") return { ...c, at: origin(c.at) };
+      const rewrite = (s, report = false) => track ? s.replace(/[a-z][\w-]*(?::[a-z][\w-]*)*/g, (name) => {
+        const d = scope2.get(`color ${name}`) ?? scope2.get(`ease ${name}`);
+        if (!d && name.includes(":") && report)
+          error("unknown-name", origin(c.at), VERBOSE ? `unknown name ${name}` : "");
+        return d?.name ?? name;
+      }) : s;
+      const offsets = [];
+      let raw = "", end = 0;
+      for (const m of c.raw.matchAll(/\{([a-z][\w-]*)\}|[a-z][\w-]*(?::[a-z][\w-]*)*/g)) {
+        const prefix = c.raw.slice(end, m.index);
+        raw += prefix;
+        for (let i = end; i < m.index; i++) offsets.push(c.at.offset + i);
+        const replacement = m[1] ? escapeText(rewrite(params[m[1]] ?? m[0], true)) : rewrite(m[0], true);
+        raw += replacement;
+        for (let i = 0; i < replacement.length; i++) offsets.push(c.at.offset + m.index);
+        end = m.index + m[0].length;
+      }
+      raw += c.raw.slice(end);
+      for (let i = end; i < c.raw.length; i++) offsets.push(c.at.offset + i);
+      return { ...c, value: rewrite(subst(c.value)), raw, offsets, at: origin(c.at) };
+    }
+    const out = {
+      ...c,
+      at: origin(c.at),
+      attrs: c.attrs.map((a) => ({
+        ...a,
+        at: origin(a.at),
+        valueAt: origin(a.valueAt),
+        value: subst(a.value)
+      })),
+      children: []
+    };
+    for (const a of out.attrs) {
+      const kind = a.name === "component" || c.name === "component" && !attr(c, "grid") && a.name === "default" ? "component" : ["model", "of"].includes(a.name) || c.name === "component" && a.name === "data" ? "model" : ["enum", "glyph"].includes(a.name) ? a.name : ["fill", "stroke", "stop-color", "value"].includes(a.name) ? "color" : ["ease", "curve"].includes(a.name) ? "ease" : "";
+      if (kind)
+        a.value = reference(
+          a.value,
+          kind,
+          scope2,
+          a.valueAt,
+          c.name === "repeat" && kind === "component"
+        );
+      a.value = a.value.replace(
+        /\$([\w:-]+):/g,
+        (_, name) => "$" + reference(name, "instance", scope2, a.valueAt) + ":"
+      );
+      if (out.name === "pose") a.value = reference(a.value, "color", scope2, a.valueAt);
+    }
+    if (c.name === "component" && attr(c, "grid"))
+      scope2 = new Map([...scope2, ...scopeFor(c, c.at.file)]);
+    out.children = children(c.children, params, scope2, uses, c.name === "track");
+    return out;
+  };
+  const stack = /* @__PURE__ */ new Set();
+  const children = (items, params, scope2, uses, track = false) => items.flatMap((c) => {
+    if (c.kind !== "element") return [clone(c, params, scope2, uses, track)];
+    if (["import", "template"].includes(c.name)) return [];
+    if (c.name !== "apply") return [clone(c, params, scope2, uses)];
+    if (c.children.some(
+      (child) => child.kind === "element" || child.kind === "text" && child.value.trim()
+    ))
+      error("misplaced-element", c.at, VERBOSE ? "apply must be empty" : "");
+    const use = clone({ ...c, children: [] }, params, scope2, uses);
+    const name = attr(use, "template"), d = scope2.get(`template ${name}`);
+    if (!d || d.el.name !== "template") {
+      error("unknown-name", use.at, VERBOSE ? `unknown template ${name}` : "");
+      return [];
+    }
+    if (stack.has(d)) {
+      error("template-recursion", d.el.at, VERBOSE ? `recursive template ${name}` : "", use.at);
+      return [];
+    }
+    const values = /* @__PURE__ */ Object.create(null);
+    const declared = /* @__PURE__ */ new Set();
+    for (const token of attr(d.el, "params").split(/\s+/).filter(Boolean)) {
+      const [key, ...rest] = token.split("=");
+      if (!NAME.test(key)) {
+        error("bad-attribute", d.el.at, VERBOSE ? "invalid parameter name" : "", use.at);
+        continue;
+      }
+      if (declared.has(key))
+        error("duplicate-name", d.el.at, VERBOSE ? "duplicate parameter" : "", use.at);
+      declared.add(key);
+      const supplied = use.attrs.find((a) => a.name === key);
+      if (supplied) values[key] = supplied.value;
+      else if (rest.length) values[key] = rest.join("=");
+      else error("missing-parameter", d.el.at, VERBOSE ? `missing parameter ${key}` : "", use.at);
+      const pattern = new RegExp(`\\{${key}\\}`);
+      if (!pattern.test(JSON.stringify(d.el.children)))
+        error("unused-parameter", d.el.at, VERBOSE ? `unused parameter ${key}` : "", use.at);
+    }
+    for (const a of use.attrs)
+      if (a.name !== "template" && !declared.has(a.name))
+        error("unknown-parameter", d.el.at, VERBOSE ? `unknown parameter ${a.name}` : "", a.at);
+    const check = (node) => {
+      if (node.kind === "comment") return;
+      const strings = node.kind === "text" ? [node.value] : node.attrs.map((a) => a.value);
+      for (const s of strings)
+        for (const m of s.matchAll(/\{([a-z][\w-]*)\}/g))
+          if (!declared.has(m[1]))
+            error(
+              "unknown-parameter",
+              node.at,
+              VERBOSE ? `undeclared parameter ${m[1]}` : "",
+              use.at
+            );
+      if (node.kind === "element") node.children.forEach(check);
+    };
+    d.el.children.forEach(check);
+    stack.add(d);
+    const result = children(d.el.children, values, d.scope, [...uses, use.at]);
+    stack.delete(d);
+    return result;
+  });
+  annotate(root, opts.file, xml);
+  const scope = scopeFor(root, opts.file);
+  const definitions = [...resources, ...scope.values()];
+  for (const d of resources.filter((d2) => d2.el.name === "component")) {
+    const original = attr(d.el, "name");
+    const qualified = d.name;
+    d.name = definitions.every(
+      (v) => v === d || v.el.name !== "component" || attr(v.el, "name") !== original
+    ) ? original : qualified;
+    componentNames[qualified] = d.name;
+  }
+  const copies = resources.map((d) => {
+    const copy = clone(d.el, {}, d.scope, []);
+    copy.attrs.find((a) => a.name === "name").value = d.name;
+    return copy;
+  });
+  root.children = [...copies, ...children(root.children, {}, scope, [])];
+  if (Object.keys(componentNames).length) {
+    let meta = root.children.find((c) => c.kind === "element" && c.name === "meta");
+    if (!meta) {
+      meta = { ...root, name: "meta", attrs: [], children: [] };
+      root.children.push(meta);
+    }
+    let value = {};
+    try {
+      value = JSON.parse(
+        meta.children.filter((c) => c.kind === "text").map((c) => c.value).join("")
+      );
+      if (!value || typeof value !== "object" || Array.isArray(value)) throw Error();
+    } catch {
+      if (meta.children.length) error("bad-attribute", meta.at, "invalid JSON metadata");
+    }
+    const text = JSON.stringify({ ...value, componentNames });
+    meta.children = meta.children.filter((c) => c.kind !== "text");
+    meta.children.push({ kind: "text", value: text, raw: escapeText(text), at: meta.at });
+  }
+}
+function relatedLocations(at) {
+  return [location(at), ...at.related ? relatedLocations(at.related) : []];
+}
+export {
+  attr,
+  expand,
+  importPath
+};

package/modules/markup-libraries/web/index.d.ts

@@ -0,0 +1,2 @@
+import 'animl/markup/libraries';
+export { compileAsync } from '../../../packages/web/src/markup.js';

package/modules/markup-libraries/web/index.js

@@ -0,0 +1,8 @@
+import "animl/markup/libraries";
+import { libraryCompiler } from "animl/markup/library-hooks";
+import { registerLibraries } from "../../../packages/web/src/markup.js";
+registerLibraries(libraryCompiler);
+import { compileAsync } from "../../../packages/web/src/markup.js";
+export {
+  compileAsync
+};

package/modules/media/core/index.d.ts

@@ -0,0 +1,2 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+export declare const media: Module;

package/modules/media/core/index.js

@@ -0,0 +1,5 @@
+import { after } from "../manifest.js";
+const media = { name: "media", after, entries: [] };
+export {
+  media
+};

package/modules/media/manifest.d.ts

@@ -0,0 +1,27 @@
+export declare const after: string[];
+declare const _default: {
+    name: string;
+    summary: string;
+    after: string[];
+    core: {
+        entry: string;
+        export: string;
+    };
+    web: {
+        name: string;
+        budget: number;
+    }[];
+    adapters: {
+        'packages/core/src/modules/media/index.ts': string;
+        'packages/web/src/media.ts': string;
+    };
+    exports: {
+        'core:./media': string;
+        'web:./media': string;
+    };
+    markupHook: null;
+    tests: string[];
+    conformance: never[];
+    docs: string[];
+};
+export default _default;

package/modules/media/manifest.js

@@ -0,0 +1,24 @@
+const after = ["assets"];
+var manifest_default = {
+  name: "media",
+  summary: "Media: icon.asset(name) loads any declared asset (audio, fonts, files) as bytes or text for page scripts.",
+  after,
+  core: { entry: "core/index.ts", export: "media" },
+  web: [{ name: "media", budget: 3072 }],
+  adapters: {
+    "packages/core/src/modules/media/index.ts": "core/index.ts",
+    "packages/web/src/media.ts": "web/index.ts"
+  },
+  exports: {
+    "core:./media": "packages/core/src/modules/media/index.ts",
+    "web:./media": "packages/web/src/media.ts"
+  },
+  markupHook: null,
+  tests: ["modules/assets/test/web/pipeline.test.ts"],
+  conformance: [],
+  docs: ["spec/SPEC.md", "docs/AUTHORING.md"]
+};
+export {
+  after,
+  manifest_default as default
+};

package/modules/media/web/index.d.ts

@@ -0,0 +1,6 @@
+import '../../assets/web/index.js';
+declare module '../../../packages/web/src/index.ts' {
+    interface AnimaIcon {
+        asset(name: string): Promise<ArrayBuffer | string>;
+    }
+}

package/modules/media/web/index.js

@@ -0,0 +1,49 @@
+import "../../assets/web/index.js";
+import { media } from "../core/index.js";
+const Icon = customElements.get("anima-icon");
+Icon.registerModule(media);
+const caches = /* @__PURE__ */ new WeakMap();
+Icon.prototype.asset = function(name) {
+  const player = this.player, model = player?.model;
+  if (!model || !Object.hasOwn(model.doc.assets ?? {}, name))
+    return Promise.reject(new RangeError("unknown asset " + name));
+  let cache = caches.get(player);
+  if (!cache) caches.set(player, cache = /* @__PURE__ */ new Map());
+  let result = cache.get(name);
+  if (!result) {
+    result = (async () => {
+      const info = model.doc.assets[name];
+      if (info.type === "image") {
+        const resolved = Icon.modules.get("assets").resolvedAssets;
+        const loaded = (resolved.get(player) ?? resolved.get(model))?.[name];
+        if (loaded) return loaded.source;
+      }
+      try {
+        const source = await this.resolveAsset(name, info);
+        if (info.type === "image" || info.type === "font") {
+          if (typeof source !== "string") throw Error("use an image resolver for Blob images");
+          return source;
+        }
+        if (source instanceof Blob) return source.arrayBuffer();
+        const response = await fetch(source);
+        if (!response.ok) throw Error("HTTP " + response.status);
+        return response.arrayBuffer();
+      } catch {
+        cache.delete(name);
+        const diagnostics = [
+          {
+            code: "asset-load",
+            severity: "error",
+            pointer: "/assets/" + name.replaceAll("~", "~0").replaceAll("/", "~1") + "/source",
+            message: "cannot load media asset " + name,
+            hint: "check source, assetPolicy and icon.assets resolver"
+          }
+        ];
+        this.dispatchEvent(new CustomEvent("anima:error", { detail: diagnostics }));
+        throw diagnostics;
+      }
+    })();
+    cache.set(name, result);
+  }
+  return result;
+};

package/modules/mesh/core/binding.d.ts

@@ -0,0 +1,3 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+/** A module-owned tuple binding parser: scalar expressions stay with bind. */
+export declare function tupleBindings(bind: Module): Module;

package/modules/mesh/core/binding.js

@@ -0,0 +1,34 @@
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+function tupleBindings(bind) {
+  const expression = bind.expression;
+  return {
+    ...bind,
+    expression(source, types, expected, p, d, read) {
+      if (expected !== "point") return expression(source, types, expected, p, d, read);
+      source = source.trim();
+      let depth = 0, comma = -1;
+      for (let k = 1; k < source.length - 1; k++) {
+        if (source[k] === "(") depth++;
+        if (source[k] === ")") depth--;
+        if (source[k] === "," && depth === 0) {
+          comma = k;
+          break;
+        }
+      }
+      if (source[0] !== "[" || !source.endsWith("]") || comma < 0) {
+        d.err(
+          "bind-type",
+          p,
+          V && "point binding needs [x-expression, y-expression]",
+          V && "use two numeric expressions inside brackets"
+        );
+        return;
+      }
+      const x = expression(source.slice(1, comma), types, "number", p, d, read), y = expression(source.slice(comma + 1, -1), types, "number", p, d, read);
+      if (x && y) return (scope) => [x(scope), y(scope)];
+    }
+  };
+}
+export {
+  tupleBindings
+};

package/modules/mesh/core/fitting.d.ts

@@ -0,0 +1,3 @@
+import type { Geometry } from '../../../packages/core/src/draw.js';
+/** Image box → fitted texture rectangle, in node-local grid units. */
+export declare function imageRect(g: Geometry): number[];

package/modules/mesh/core/fitting.js

@@ -0,0 +1,11 @@
+function imageRect(g) {
+  const r = g.image, w = g.width, h = g.height, iw = r.width ?? w, ih = r.height ?? h;
+  const sx = w / iw, sy = h / ih;
+  const scale = r.fit === "cover" ? Math.max(sx, sy) : r.fit === "none" ? 1 : r.fit === "scale-down" ? Math.min(1, sx, sy) : r.fit === "fit-width" ? sx : r.fit === "fit-height" ? sy : Math.min(sx, sy);
+  const fill = r.fit === "fill" || r.fit === "resize", dw = fill ? w : iw * scale, dh = fill ? h : ih * scale;
+  const align = (low, high) => r.align.includes(low) ? 0 : r.align.includes(high) ? 1 : 0.5;
+  return [(w - dw) * align("left", "right"), (h - dh) * align("top", "bottom"), dw, dh];
+}
+export {
+  imageRect
+};

package/modules/mesh/core/index.d.ts

@@ -0,0 +1,7 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+export interface Mesh {
+    vertices: number[][];
+    triangles: number[][];
+}
+export declare function gridMesh(r: Record<string, any>, g?: any): Mesh;
+export declare const mesh: Module;