animl 0.0.0-stage → 0.1.0

package/modules/focus/core/index.js

@@ -0,0 +1,318 @@
+import { registerEventKinds } from "../../components/core/events.js";
+import { apply, invert, mul, IDENTITY } from "../../../packages/core/src/geom.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { after } from "../manifest.js";
+const state = /* @__PURE__ */ new WeakMap();
+const installed = /* @__PURE__ */ new WeakSet();
+let pointerDepth = 0;
+const str = (of) => ({ k: "str", of });
+const config = {
+  k: "obj",
+  element: "focus",
+  p: {
+    enabled: { k: "bool" },
+    enabledInput: { k: "str", markup: "enabled-input" },
+    tabStops: { k: "bool", markup: "tab-stops" },
+    pointer: { k: "bool" },
+    order: { k: "num" },
+    scope: { k: "bool" },
+    edge: str(["stop", "closed-loop", "parent-scope"]),
+    label: str(),
+    bounds: {
+      k: "tup",
+      min: 4,
+      of: [{ k: "num" }, { k: "num" }, { k: "num", min: 0 }, { k: "num", min: 0 }]
+    }
+  }
+};
+const cfg = (p, i) => p.model.nodes[i].raw.focus;
+const eligible = (p, i) => {
+  const f = cfg(p, i);
+  if (!f || f.enabled === false || f.enabledInput !== void 0 && !p.get(f.enabledInput))
+    return false;
+  return p.visible(i);
+};
+const scope = (p, i) => {
+  for (let n = p.model.nodes[i].parent; n >= 0; n = p.model.nodes[n].parent)
+    if (cfg(p, n)?.scope) return n;
+  return -1;
+};
+const contains = (p, ancestor, node) => {
+  while (node >= 0 && node !== ancestor) node = p.model.nodes[node].parent;
+  return node === ancestor;
+};
+const point = (p, i) => {
+  const [x, y, w, h] = cfg(p, i)?.bounds ?? [0, 0, 0, 0];
+  return apply(p.world(i), x + w / 2, y + h / 2);
+};
+function install(P, modules) {
+  if (installed.has(P.prototype)) return;
+  installed.add(P.prototype);
+  Object.defineProperty(P.prototype, "focused", {
+    configurable: true,
+    get() {
+      return state.get(this) ?? null;
+    }
+  });
+  P.prototype.machineFocus = function(nodeId) {
+    return this.focused === nodeId;
+  };
+  P.prototype.focusItems = function(includeDisabled = false) {
+    const items = this.model.nodes.flatMap(
+      (n, i) => (includeDisabled ? !!cfg(this, i) : eligible(this, i)) ? [{ id: n.id, node: i, config: cfg(this, i) }] : []
+    ).sort((a, b) => (a.config.order ?? 0) - (b.config.order ?? 0) || a.node - b.node);
+    let seq = 0;
+    const append = (child, name, node, matrix = this.world(node)) => {
+      if (!includeDisabled && !this.visible(node)) return;
+      seq++;
+      for (const item of child.focusItems(includeDisabled))
+        items.push({
+          ...item,
+          id: name + "." + item.id,
+          node,
+          rank: [
+            this.paintRank?.(node) ?? node,
+            seq,
+            ...item.rank ?? [child.paintRank?.(item.node) ?? item.node]
+          ],
+          matrix: mul(matrix, item.matrix ?? IDENTITY),
+          owner: item.owner ?? child,
+          local: item.local ?? item.id,
+          point: apply(matrix, ...item.point ?? point(child, item.node))
+        });
+    };
+    for (const [name, child] of this.nested?.players ?? [])
+      append(child, name, this.model.ids.get(name));
+    const lists = modules.get("lists");
+    for (const run of lists?.listState(this)?.runs ?? []) {
+      const node = run.spec.node, raw = this.model.nodes[node].raw;
+      for (const item of run.items)
+        append(
+          item.player,
+          raw.id + "." + item.index,
+          node,
+          mul(this.world(node), [
+            1,
+            0,
+            0,
+            1,
+            (raw.dx ?? 0) * item.index,
+            (raw.dy ?? 0) * item.index
+          ])
+        );
+    }
+    return items;
+  };
+  P.prototype.focusTarget = function(id) {
+    const next = this.focusItems().find((n) => n.id === id);
+    if (id !== null && !next) return false;
+    const old = this.focused;
+    if (old === id) return false;
+    const previous = this.focusItems(true).find((n) => n.id === old);
+    if (previous?.owner && previous.owner !== next?.owner) previous.owner.focusClear();
+    if (next?.owner) next.owner.focusTarget(next.local);
+    state.set(this, id);
+    for (const [on, target] of [
+      ["blur", old],
+      ["focus", id]
+    ])
+      if (target !== null) {
+        for (const l of this.model.listeners)
+          if (l.on === on && (l.target < 0 || this.model.nodes[l.target].id === target))
+            this.act(l);
+      }
+    this.onFocusChange?.(id);
+    this.onChange?.();
+    return true;
+  };
+  P.prototype.focusKey = function(key, down = true, shift = false) {
+    const dirs = {
+      ArrowLeft: "left",
+      ArrowRight: "right",
+      ArrowUp: "up",
+      ArrowDown: "down"
+    };
+    const dir = dirs[key] ?? (key === "Tab" && this.focusItems(true).some((n) => n.config.tabStops) ? shift ? "previous" : "next" : void 0);
+    return down && dir ? this.focusTraverse(dir) : false;
+  };
+  P.prototype.focusClear = function() {
+    return this.focusTarget(null);
+  };
+  P.prototype.focusTraverse = function(direction = "next") {
+    if (!["next", "previous", "left", "right", "up", "down"].includes(direction))
+      throw Error(V ? "anima: invalid focus direction" : "anima: focus");
+    const all = this.focusItems(), current = all.find((n) => n.id === this.focused);
+    const reverse = ["previous", "left", "up"].includes(direction);
+    if (!current) return this.focusTarget((reverse ? all.at(-1) : all[0])?.id ?? null);
+    if (current.owner) {
+      if (current.owner.focusTraverse(direction))
+        return this.focusTarget(
+          current.id.slice(0, -current.local.length) + current.owner.focused
+        );
+      if (cfg(this, current.node)?.edge !== "parent-scope") return false;
+    }
+    const sequential = direction === "next" || direction === "previous";
+    let s = scope(this, current.node);
+    const visited = /* @__PURE__ */ new Set();
+    while (!visited.has(s)) {
+      visited.add(s);
+      const items = all.filter(
+        (n) => scope(this, n.node) === s || visited.size > 1 && contains(this, s, n.node)
+      );
+      let next;
+      if (sequential) {
+        const at = items.indexOf(current);
+        next = items[at + (reverse ? -1 : 1)];
+      } else {
+        const [x, y] = current.point ?? point(this, current.node);
+        let best = Infinity;
+        for (const n of items) {
+          if (contains(this, n.node, this.model.nodes[current.node].parent)) continue;
+          const [nx, ny] = n.point ?? point(this, n.node), dx = nx - x, dy = ny - y;
+          const forward = direction === "left" ? -dx : direction === "right" ? dx : direction === "up" ? -dy : dy;
+          const score = dx * dx + dy * dy;
+          if (forward > 0 && score < best) {
+            best = score;
+            next = n;
+          }
+        }
+      }
+      if (next) return this.focusTarget(next.id);
+      const edge = s < 0 ? "stop" : cfg(this, s)?.edge ?? "stop";
+      if (edge === "stop") return false;
+      if (edge === "closed-loop") {
+        if (sequential) next = reverse ? items.at(-1) : items[0];
+        else {
+          const axis = direction === "left" || direction === "right" ? 0 : 1;
+          next = [...items].sort(
+            (a, b) => ((a.point ?? point(this, a.node))[axis] - (b.point ?? point(this, b.node))[axis]) * (reverse ? -1 : 1) || a.node - b.node
+          )[0];
+        }
+        return next ? this.focusTarget(next.id) : false;
+      }
+      s = scope(this, s);
+    }
+    return false;
+  };
+  P.prototype.focusPointer = function(x, y, accept) {
+    const item = this.focusItems().filter(
+      (n) => n.config.pointer !== false && (!accept || accept(n.node)) && (n.owner ? n.owner.focusItems().some((i) => i.id === n.local) && (() => {
+        const inv = invert(n.matrix);
+        return inv ? n.owner.hits(
+          { target: n.owner.model.ids.get(n.local), pad: 0 },
+          ...apply(inv, x, y)
+        ) : false;
+      })() : this.hits({ target: n.node, pad: 0 }, x, y))
+    ).sort((a, b) => {
+      const r = a.rank ?? [this.paintRank?.(a.node) ?? a.node], q = b.rank ?? [this.paintRank?.(b.node) ?? b.node];
+      for (let i = 0; i < r.length || i < q.length; i++)
+        if ((q[i] ?? -1) !== (r[i] ?? -1)) return (q[i] ?? -1) - (r[i] ?? -1);
+      return 0;
+    })[0];
+    return item ? this.focusTarget(item.id) : false;
+  };
+  const pointer = P.prototype.pointer, step = P.prototype.step;
+  P.prototype.pointer = function(kind, x = 0, y = 0) {
+    if (!pointerDepth && kind === "down" && !this.model.doc.requires?.includes("input"))
+      this.focusPointer(x, y);
+    pointerDepth++;
+    try {
+      pointer.call(this, kind, x, y);
+    } finally {
+      pointerDepth--;
+    }
+  };
+  P.prototype.step = function(...args) {
+    const result = step.apply(this, args);
+    if (this.focused && !this.focusItems().some((n) => n.id === this.focused)) {
+      this.focusClear();
+      result.settled = false;
+    }
+    this.onFocusRefresh?.();
+    return result;
+  };
+}
+const focus = {
+  name: "focus",
+  after,
+  entries: [
+    {
+      target: "node",
+      shapes: { focus: config },
+      elements: {
+        focus: {
+          shape: config,
+          target: { attribute: "property", choices: ["focus"], default: "focus" }
+        }
+      }
+    }
+  ],
+  init(_modules, shared) {
+    install(shared.Player, _modules);
+    registerEventKinds(_modules, "focus", ["focus", "blur"]);
+    const listeners = shared.DOC.p.listeners;
+    const shape = listeners.of;
+    const on = shape.p.on;
+    return {
+      ...focus,
+      init: void 0,
+      entries: [
+        ...focus.entries,
+        {
+          target: "document",
+          shapes: {
+            listeners: {
+              ...listeners,
+              feature: "",
+              of: {
+                ...shape,
+                p: {
+                  ...shape.p,
+                  on: {
+                    ...on,
+                    re: on.k === "str" && on.re ? new RegExp(on.re.source.replace("enter|", "focus|blur|enter|")) : void 0,
+                    of: on.k === "str" && on.of ? [...on.of, "focus", "blur"] : void 0
+                  }
+                }
+              }
+            }
+          }
+        }
+      ]
+    };
+  },
+  load(model, raw, d) {
+    for (const [i, l] of (raw.listeners ?? []).entries())
+      if (["focus", "blur"].includes(l.on) && !raw.requires?.includes("focus"))
+        d.err(
+          "undeclared-feature",
+          `/listeners/${i}/on`,
+          V && "focus listener requires focus",
+          V && 'add "focus" to requires'
+        );
+    const paths = /* @__PURE__ */ new Map();
+    const visit = (nodes, base) => nodes.forEach((n, i) => {
+      const p = base + "/" + i;
+      paths.set(n, p);
+      if (n.children) visit(n.children, p + "/children");
+    });
+    visit(raw.nodes, "/nodes");
+    model.nodes.forEach((n) => {
+      const f = n.raw.focus;
+      if (f?.enabledInput !== void 0) {
+        const input = model.inputs.get(f.enabledInput), p = paths.get(n.raw) + "/focus/enabledInput";
+        const warning = d.list.findIndex(
+          (e) => e.code === "unused-input" && e.pointer === "/inputs/" + f.enabledInput
+        );
+        if (warning >= 0) d.list.splice(warning, 1);
+        if (!input)
+          d.err("unknown-input", p, V && "unknown focus enabled input", V && "name a bool input");
+        else if (input.type !== "bool")
+          d.err("input-type", p, V && "focus enabled input must be bool", V && "name a bool input");
+      }
+    });
+  }
+};
+export {
+  focus
+};

package/modules/focus/core/svg.d.ts

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

package/modules/focus/core/svg.js

@@ -0,0 +1,4 @@
+const focusSVG = {};
+export {
+  focusSVG
+};

package/modules/focus/manifest.d.ts

@@ -0,0 +1,31 @@
+export declare const after: string[];
+declare const _default: {
+    after: string[];
+    name: string;
+    summary: string;
+    core: {
+        entry: string;
+        export: string;
+        svg: string;
+        svgExport: string;
+    };
+    web: {
+        name: string;
+        budget: number;
+    }[];
+    adapters: {
+        'packages/core/src/modules/focus/index.ts': string;
+        'packages/core/src/modules/focus/svg.ts': string;
+        'packages/markup/src/focus.ts': string;
+        'packages/web/src/focus.ts': string;
+    };
+    exports: {
+        'core:./focus': string;
+        'markup:./focus': string;
+        'web:./focus': string;
+    };
+    tests: string[];
+    conformance: string[];
+    docs: string[];
+};
+export default _default;

package/modules/focus/manifest.js

@@ -0,0 +1,50 @@
+const after = ["components"];
+var manifest_default = {
+  ...{
+    name: "focus",
+    summary: "Keyboard focus: focusable nodes, focus order, focus states and focus-driven listeners.",
+    after: [],
+    core: { entry: "core/index.ts", export: "focus", svg: "core/svg.ts", svgExport: "focusSVG" },
+    web: [{ name: "focus", budget: 3456 }],
+    adapters: {
+      "packages/core/src/modules/focus/index.ts": "core/index.ts",
+      "packages/core/src/modules/focus/svg.ts": "core/svg.ts",
+      "packages/markup/src/focus.ts": "markup/index.ts",
+      "packages/web/src/focus.ts": "web/index.ts"
+    },
+    exports: {
+      "core:./focus": "packages/core/src/modules/focus/index.ts",
+      "markup:./focus": "packages/markup/src/focus.ts",
+      "web:./focus": "packages/web/src/focus.ts"
+    },
+    tests: [
+      "modules/focus/test/**/*.test.ts",
+      "packages/markup/test/corpus.test.ts",
+      "packages/markup/test/names.test.ts"
+    ],
+    conformance: [
+      "input-focus-clear",
+      "input-focus-down",
+      "input-focus-edge-closed-loop",
+      "input-focus-edge-parent-scope",
+      "input-focus-edge-stop",
+      "input-focus-enabled",
+      "input-focus-left",
+      "input-focus-next",
+      "input-focus-previous",
+      "input-focus-pointer",
+      "input-focus-right",
+      "input-focus-target",
+      "input-focus-traverse",
+      "input-focus-up",
+      "input-listen-blur",
+      "input-listen-focus"
+    ],
+    docs: ["spec/SPEC.md", "spec/ANIML.md", "docs/WEB.md"]
+  },
+  after
+};
+export {
+  after,
+  manifest_default as default
+};

package/modules/focus/markup/index.d.ts

@@ -0,0 +1 @@
+export { structuralMarkup as focusMarkup } from '../../paint/markup/index.js';

package/modules/focus/markup/index.js

@@ -0,0 +1,4 @@
+import { structuralMarkup } from "../../paint/markup/index.js";
+export {
+  structuralMarkup as focusMarkup
+};

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

@@ -0,0 +1,7 @@
+import '../../../packages/web/src/index.js';
+declare module '../../../packages/web/src/index.ts' {
+    interface AnimaIcon {
+        focusNext(): boolean;
+        focusPrevious(): boolean;
+    }
+}

package/modules/focus/web/index.js

@@ -0,0 +1,166 @@
+import { focus } from "../core/index.js";
+import "../../../packages/web/src/index.js";
+const Icon = customElements.get("anima-icon");
+Icon.registerModule(focus);
+Icon.prototype.focusNext = function() {
+  return this.player?.focusTraverse("next") ?? false;
+};
+Icon.prototype.focusPrevious = function() {
+  return this.player?.focusTraverse("previous") ?? false;
+};
+const attached = /* @__PURE__ */ new WeakMap();
+const drawn = /* @__PURE__ */ new WeakMap();
+function attach(icon) {
+  attached.get(icon)?.();
+  icon.setAttribute("data-focus-ready", "");
+  const abort = new AbortController();
+  let box;
+  let player = icon.player;
+  let saved;
+  let refresh;
+  let ids = "";
+  const listen = (type, fn) => icon.addEventListener(type, fn, { signal: abort.signal });
+  const own = () => {
+    if (box && player === icon.player && !player?.model.doc.a11y) {
+      icon.removeAttribute("aria-hidden");
+      icon.setAttribute("role", "group");
+    }
+  };
+  const build = () => {
+    box?.remove();
+    box = void 0;
+    if (player) {
+      player.onFocusChange = saved;
+      player.onFocusRefresh = refresh;
+    }
+    player = icon.player;
+    if (!player?.model.doc.requires?.includes("focus")) return;
+    const p = player, items = p.focusItems(true), inner = items.some((n) => n.config.tabStops);
+    ids = items.map((n) => n.id).join();
+    saved = p.onFocusChange;
+    refresh = p.onFocusRefresh;
+    const changed = () => p.focusItems(true).map((n) => n.id).join() !== ids && (build(), true);
+    if (!items.length) {
+      p.onFocusRefresh = () => changed() || refresh?.();
+      return;
+    }
+    box = document.createElement("span");
+    box.style.cssText = "position:absolute;inset:0;pointer-events:none";
+    const targets = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      const semantic = Icon.semanticElement?.(icon, item.id);
+      const owner = item.owner ?? p;
+      if (semantic === null && owner.model.nodes[owner.model.ids.get(item.local ?? item.id)]?.raw.a11y)
+        continue;
+      const el = semantic ?? document.createElement("span");
+      if (!semantic || !inner) el.tabIndex = inner ? 0 : -1;
+      if (!semantic) {
+        el.setAttribute("role", "button");
+        el.setAttribute("aria-label", item.config.label ?? item.id);
+        el.style.cssText = "position:absolute;width:1px;height:1px;overflow:hidden";
+        box.append(el);
+      }
+      el.dataset.focus = item.id;
+      if (!semantic)
+        el.onfocus = () => {
+          p.focusTarget(item.id);
+        };
+      targets.set(item.id, el);
+    }
+    icon.shadowRoot.append(box);
+    own();
+    if (inner) icon.removeAttribute("tabindex");
+    else icon.tabIndex = 0;
+    p.onFocusRefresh = () => {
+      if (changed()) return;
+      refresh?.();
+      const eligible = new Set(p.focusItems().map((n) => n.id));
+      for (const [id, el] of targets) {
+        const hidden = !eligible.has(id), tab = !hidden && (inner || p.focused === id) ? 0 : -1;
+        if (!el.dataset.semantic && el.hidden !== hidden) el.hidden = hidden;
+        if ((hidden || !(inner && el.dataset.semantic)) && el.tabIndex !== tab) el.tabIndex = tab;
+      }
+    };
+    p.onFocusRefresh();
+    p.onFocusChange = (id) => {
+      saved?.(id);
+      for (const [name, el] of targets)
+        if (!(inner && el.dataset.semantic)) el.tabIndex = inner || name === id ? 0 : -1;
+      if (id) {
+        if (inner) icon.removeAttribute("tabindex");
+        else icon.tabIndex = -1;
+        targets.get(id)?.focus({ preventScroll: true });
+      } else if (icon.shadowRoot?.activeElement) {
+        icon.shadowRoot.activeElement.blur();
+      }
+    };
+    if (p.focused) p.onFocusChange(p.focused);
+  };
+  listen("anima:load", build);
+  listen("anima:state", own);
+  const labels = new MutationObserver(own);
+  labels.observe(icon, { attributeFilter: ["label"] });
+  abort.signal.addEventListener("abort", () => labels.disconnect());
+  listen("anima:overlay", build);
+  listen("pointerdown", (event) => {
+    if (icon.player?.focused && !event.composedPath()[0]?.hasAttribute?.("data-semantic"))
+      event.preventDefault();
+  });
+  listen("focus", () => {
+    const p = icon.player;
+    if (p?.model.doc.requires?.includes("focus") && !icon.shadowRoot?.activeElement) {
+      const id = p.focused ?? p.focusItems()[0]?.id;
+      if (id) {
+        if (!p.focusTarget(id))
+          icon.shadowRoot?.querySelector(`[data-focus="${id}"]`)?.focus();
+      }
+    }
+  });
+  listen(
+    "focusout",
+    () => queueMicrotask(() => {
+      if (!icon.matches(":focus-within") && icon.player?.model.doc.requires?.includes("focus")) {
+        icon.player.focusClear();
+        if (!icon.player.focusItems(true).some((n) => n.config.tabStops)) icon.tabIndex = 0;
+      }
+    })
+  );
+  listen("keydown", ((event) => {
+    if (!icon.player?.model.doc.requires?.includes("focus") || icon.hasAttribute("paused")) return;
+    if (icon.player.model.doc.requires?.includes("input")) return;
+    if (event.composedPath()[0]?.hasAttribute?.("data-semantic")) return;
+    if (!event.altKey && !event.ctrlKey && !event.metaKey && icon.player.focusKey(event.key, true, event.shiftKey))
+      event.preventDefault();
+  }));
+  build();
+  drawn.set(icon, () => box && !box.parentNode && icon.shadowRoot.append(box));
+  attached.set(icon, () => {
+    drawn.delete(icon);
+    abort.abort();
+    box?.remove();
+    if (player) {
+      player.onFocusChange = saved;
+      player.onFocusRefresh = refresh;
+    }
+    attached.delete(icon);
+  });
+}
+const load = Icon.prototype.load, loadModel = Icon.prototype.loadModel, destroy = Icon.prototype.destroy;
+Icon.prototype.load = function(doc, markup = false) {
+  if (!attached.has(this)) attach(this);
+  return load.call(this, doc, markup);
+};
+Icon.prototype.loadModel = function(model) {
+  if (!attached.has(this)) attach(this);
+  loadModel.call(this, model);
+};
+const previousEvent = Icon.eventHook;
+Icon.eventHook = (icon, kind, detail) => {
+  previousEvent?.(icon, kind, detail);
+  if (kind === "draw") drawn.get(icon)?.();
+};
+Icon.prototype.destroy = function() {
+  attached.get(this)?.();
+  destroy.call(this);
+};
+for (const icon of document.querySelectorAll("anima-icon")) attach(icon);

package/modules/fonts/core/css.d.ts

@@ -0,0 +1,20 @@
+/** Structural subset of text's FontSpec; no text runtime dependency. */
+export interface FontStyle {
+    family: string;
+    size: number;
+    weight: number;
+    style: 'normal' | 'italic';
+    axes?: Record<string, number>;
+    features?: Record<string, number>;
+    tracking: number;
+}
+export declare function cssFont(spec: FontStyle): {
+    font: string;
+    fontFamily: string;
+    fontSize: string;
+    fontWeight: string;
+    fontStyle: "normal" | "italic";
+    letterSpacing: string;
+    fontVariationSettings: string;
+    fontFeatureSettings: string;
+};

package/modules/fonts/core/css.js

@@ -0,0 +1,16 @@
+function cssFont(spec) {
+  const tags = (values) => Object.entries(values ?? {}).map(([tag, value]) => `${JSON.stringify(tag)} ${value}`).join(", ") || "normal";
+  return {
+    font: `${spec.style} ${spec.weight} ${spec.size}px ${spec.family}`,
+    fontFamily: spec.family,
+    fontSize: `${spec.size}px`,
+    fontWeight: String(spec.weight),
+    fontStyle: spec.style,
+    letterSpacing: `${spec.tracking}px`,
+    fontVariationSettings: tags(spec.axes),
+    fontFeatureSettings: tags(spec.features)
+  };
+}
+export {
+  cssFont
+};

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

@@ -0,0 +1,21 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+import type { HostData } from '../../host/core/api.js';
+export { cssFont, type FontStyle } from './css.js';
+export interface FontModule extends Module {
+    /** Compose the text registry and retain its live measurer setter. */
+    use: (entries: import('../../../packages/core/src/modules.js').ModuleEntry[], set: typeof import('../../text/core/measure.js').registerTextMeasurer) => void;
+    setMeasurer?: typeof import('../../text/core/measure.js').registerTextMeasurer;
+    refreshText?: (player: import('../../../packages/core/src/player.js').Player) => void;
+    prepareText?: (player: import('../../../packages/core/src/player.js').Player, input: import('../../text/core/layout.js').LayoutInput) => {
+        revision: number;
+        layout?: import('../../text/core/layout.js').TextLayout;
+    } | undefined;
+    controller?: (player: import('../../../packages/core/src/player.js').Player) => {
+        revision: number;
+        ready(spec: import('./css.js').FontStyle, text?: string): Promise<void>;
+        cssFont: typeof import('./css.js').cssFont;
+    } | undefined;
+    accepts?: (face: unknown) => face is object;
+    assign?: (api: HostData, path: string, face: object) => Promise<void>;
+}
+export declare const fonts: FontModule;