animl 0.0.0-stage → 0.1.0

package/modules/a11y/core/runtime.d.ts

@@ -0,0 +1,37 @@
+import type { Player } from '../../../packages/core/src/player.js';
+import type { Module } from '../../../packages/core/src/modules.js';
+import { type Mat } from '../../../packages/core/src/geom.js';
+import type { A11yConfig, SemanticNode } from './types.js';
+import { flat } from './tree.js';
+export interface Entry {
+    p: Player;
+    i: number;
+    id: string;
+    parent: string;
+    matrix: Mat;
+    config?: A11yConfig;
+    data: Record<string, unknown>;
+    visible: boolean;
+    bounds?: SemanticNode['bounds'];
+}
+export interface Cache {
+    signature: string;
+    valid: () => boolean;
+    tree: SemanticNode[];
+    entries: Entry[];
+}
+declare const caches: WeakMap<Player, Cache>;
+/** Shared through the active registry, including separately bundled action entries. */
+export declare const runtime: {
+    caches: typeof caches;
+    flat: typeof flat;
+    bounds?: typeof import('./bounds.js').paintedBounds;
+    version?: number;
+    enrich?: (entries: Entry[], track: <T>(read: () => T) => T) => void;
+    /** Runs after `enrich`, before the signature; owned by text-input so `enrich` can be replaced. */
+    refine?: (entries: Entry[]) => void;
+    update?: (p: Player, cache: Cache, previous?: Cache) => boolean;
+};
+export declare function install(P: typeof Player, modules: ReadonlyMap<string, Module>): void;
+export declare function prepare(model: import('../../../packages/core/src/load.js').Model): void;
+export {};

package/modules/a11y/core/runtime.js

@@ -0,0 +1,201 @@
+import { drawFrame, drawWorld } from "../../../packages/core/src/draw.js";
+import { apply, mul, IDENTITY } from "../../../packages/core/src/geom.js";
+import { parsePath, flatten } from "../../../packages/core/src/path.js";
+import { states } from "./registry.js";
+import { flat } from "./tree.js";
+const caches = /* @__PURE__ */ new WeakMap();
+const runtime = { caches, flat };
+function box(points) {
+  const xs = points.map((p) => p[0]), ys = points.map((p) => p[1]);
+  const x = Math.min(...xs), y = Math.min(...ys);
+  return [x, y, Math.max(...xs) - x, Math.max(...ys) - y];
+}
+function install(P, modules) {
+  if ("semantics" in P.prototype) return;
+  P.prototype.semantics = function() {
+    const old = caches.get(this);
+    if (old?.valid()) return old.tree;
+    const checks = [];
+    const track = (read) => {
+      const value = read();
+      checks.push(() => read() === value);
+      return value;
+    };
+    track(() => runtime.version);
+    track(() => runtime.enrich);
+    track(() => runtime.refine);
+    track(() => runtime.bounds);
+    const entries = [];
+    const collect = (p, prefix = "", parent = "", matrix = IDENTITY, visible = true) => {
+      for (const [address, { key }] of p.model.addrs)
+        if (!(runtime.bounds ? /^(opacity|drawOrder)/ : /^(opacity|fill|stroke|paints|drawOrder)/).test(key))
+          track(() => p.value(address));
+      track(() => p.focused);
+      const children = p.nested?.players;
+      track(() => children?.size);
+      const frame = drawFrame(p);
+      track(() => p.drawRevision);
+      p.model.nodes.forEach((n, i) => {
+        const c = n.raw.a11y;
+        const m = mul(matrix, drawWorld(p, i, frame)), g = frame.nodes[i]?.geometry;
+        let points = [];
+        let bounds = c?.bounds;
+        if (!bounds && g) {
+          if (g.d)
+            points = flatten(parsePath(g.d)).flatMap(
+              (poly) => Array.from(
+                { length: poly.pts.length / 2 },
+                (_, i2) => poly.pts.slice(i2 * 2, i2 * 2 + 2)
+              )
+            );
+          else if (g.r !== void 0) bounds = [g.cx - g.r, g.cy - g.r, g.r * 2, g.r * 2];
+          else if (g.width !== void 0) bounds = [g.x ?? 0, g.y ?? 0, g.width, g.height ?? 0];
+        }
+        if (bounds) {
+          const [x, y, w, h] = bounds;
+          points = [
+            [x, y],
+            [x + w, y],
+            [x, y + h],
+            [x + w, y + h]
+          ];
+        }
+        const data = { ...c };
+        for (const k in data)
+          if (typeof data[k] === "string" && !["role", "live", "href", "activate", "controls"].includes(k))
+            data[k] = track(() => p.get(c[k])) ?? data[k];
+        if (n.raw.focus?.enabledInput)
+          data.focusEnabled = track(() => p.get(n.raw.focus.enabledInput));
+        const entry = {
+          p,
+          i,
+          id: prefix + n.id,
+          parent: n.parent < 0 ? parent : prefix + p.model.nodes[n.parent].id,
+          matrix: m,
+          config: c,
+          data,
+          visible: visible && p.visible(i) && !data.hidden,
+          bounds: !c?.bounds && runtime.bounds ? runtime.bounds(frame.nodes[i], m) : points.length ? box(points.map((pt) => apply(m, ...pt))) : void 0
+        };
+        entries.push(entry);
+        for (const [id, child] of children ?? []) {
+          if (id === n.id) {
+            track(() => children.get(id));
+            collect(child, prefix + id + ".", entry.id, entry.matrix, entry.visible);
+          }
+        }
+        const lists = modules.get("lists");
+        for (const run of (lists?.listState(p)?.runs ?? []).filter((r) => r.spec.node === i)) {
+          track(() => run.items.length);
+          for (const item of run.items) {
+            const index = item.index;
+            track(() => run.items[index]?.player);
+            const raw = p.model.nodes[run.spec.node].raw;
+            collect(
+              item.player,
+              entry.id + "." + item.index + ".",
+              entry.id,
+              mul(entry.matrix, [
+                1,
+                0,
+                0,
+                1,
+                (raw.dx ?? 0) * item.index,
+                (raw.dy ?? 0) * item.index
+              ]),
+              entry.visible
+            );
+          }
+        }
+      });
+    };
+    collect(this);
+    runtime.enrich?.(entries, track);
+    runtime.refine?.(entries);
+    const owners = new Map(entries.map((e) => [e.id, e]));
+    for (const e of [...entries].reverse()) {
+      if (e.bounds) continue;
+      const points = entries.filter((c) => c.parent === e.id && c.visible && c.bounds).flatMap((c) => {
+        const [x, y, w, h] = c.bounds;
+        return [
+          [x, y],
+          [x + w, y + h]
+        ];
+      });
+      if (points.length) e.bounds = box(points);
+    }
+    const signature = JSON.stringify([
+      runtime.version,
+      entries.map((e) => [e.id, e.parent, e.data, e.visible, e.bounds, e.p.focused])
+    ]);
+    const valid = () => checks.every((check) => check());
+    if (old?.signature === signature) {
+      old.entries = entries;
+      old.valid = valid;
+      return old.tree;
+    }
+    const nodes = /* @__PURE__ */ new Map();
+    const tree = [];
+    const excluded = /* @__PURE__ */ new Set();
+    for (const e of entries) {
+      if (!e.visible || excluded.has(e.parent)) {
+        excluded.add(e.id);
+        continue;
+      }
+      if (!e.config || e.data.role === "none") continue;
+      const c = e.config, d = e.data;
+      const n = {
+        id: e.id,
+        role: c.role,
+        states: {},
+        bounds: e.bounds ?? [...apply(e.matrix, 0, 0), 0, 0],
+        actions: [],
+        children: []
+      };
+      for (const key of "label hint value valueText level href".split(" "))
+        if (d[key] !== void 0) n[key] = d[key];
+      if (c.controls) n.controls = e.id.slice(0, -e.p.model.nodes[e.i].id.length) + c.controls;
+      if (c.role === "status") n.states.live = "polite";
+      for (const key of states)
+        if (key !== "hidden" && d[key] !== void 0)
+          n.states[key] = d[key];
+      if (d.checkedMixed) n.states.checked = "mixed";
+      if (c.live && c.live !== "off") n.states.live = c.live;
+      if (!d.disabled && c.role === "slider" || ["progressbar", "meter"].includes(c.role)) {
+        n.min = c.min ?? 0;
+        n.max = c.max ?? 100;
+        if (c.role === "slider") n.step = c.step ?? 1;
+      }
+      let parent = owners.get(e.parent);
+      while (parent && !nodes.has(parent.id)) parent = owners.get(parent.parent);
+      (parent ? nodes.get(parent.id).children : tree).push(n);
+      nodes.set(e.id, n);
+    }
+    const prune = (list) => {
+      const modal = list.find((n) => n.states.modal);
+      if (modal) list.splice(0, list.length, modal);
+      list.forEach((n) => prune(n.children));
+    };
+    prune(tree);
+    const cache = { signature, tree, entries, valid };
+    caches.set(this, cache);
+    if (runtime.update?.(this, cache, old)) {
+      caches.delete(this);
+      return this.semantics();
+    }
+    return tree;
+  };
+}
+function prepare(model) {
+  if (!model.doc.requires?.includes("a11y")) return;
+  const previous = model.afterStep;
+  model.afterStep = (p) => {
+    previous?.(p);
+    p.semantics();
+  };
+}
+export {
+  install,
+  prepare,
+  runtime
+};

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

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

package/modules/a11y/core/svg.js

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

package/modules/a11y/core/text.d.ts

@@ -0,0 +1,4 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+import type { runtime as Runtime } from './runtime.js';
+/** Optional consumer of the active text module; neither text nor its measurer is bundled here. */
+export declare function installTextSemantics(runtime: typeof Runtime, modules: ReadonlyMap<string, Module>): void;

package/modules/a11y/core/text.js

@@ -0,0 +1,55 @@
+import { apply } from "../../../packages/core/src/geom.js";
+function installTextSemantics(runtime, modules) {
+  runtime.enrich = (entries, track) => {
+    const text = modules.get("text");
+    if (!text) return;
+    const content = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      if (String(e.p.model.nodes[e.i].type) !== "text") continue;
+      const layout = track(() => text.textLayout(e.p, e.i));
+      content.set(
+        e.id,
+        track(
+          () => text.input(e.p, e.i).runs.map((r) => r.text).join("")
+        )
+      );
+      if (e.config?.bounds) continue;
+      const points = layout.lines.flatMap((l) => {
+        const xs = l.clusters.flatMap((c) => [c.x, c.x + c.advance]);
+        const x = xs.length ? Math.min(...xs) : l.x ?? 0;
+        const y = l.baseline - l.ascent * layout.scale;
+        let left = x, top = y, right = xs.length ? Math.max(...xs) : x, bottom = l.baseline + l.descent * layout.scale;
+        if (layout.clip) {
+          const [cx, cy, w, h] = layout.clip;
+          if (right < cx || left > cx + w || bottom < cy || top > cy + h) return [];
+          left = Math.max(left, cx);
+          top = Math.max(top, cy);
+          right = Math.max(left, Math.min(right, cx + w));
+          bottom = Math.max(top, Math.min(bottom, cy + h));
+        }
+        return [
+          [left, top],
+          [right, top],
+          [left, bottom],
+          [right, bottom]
+        ].map(([x2, y2]) => apply(e.matrix, x2, y2));
+      });
+      if (points.length) {
+        const xs = points.map((p) => p[0]), ys = points.map((p) => p[1]);
+        const x = Math.min(...xs), y = Math.min(...ys);
+        e.bounds = [x, y, Math.max(...xs) - x, Math.max(...ys) - y];
+      } else e.bounds = [...apply(e.matrix, 0, 0), 0, 0];
+    }
+    const owners = new Map(entries.map((e) => [e.id, e]));
+    for (const e of entries) e.visible &&= owners.get(e.parent)?.visible ?? true;
+    for (const e of [...entries].reverse()) {
+      if (!e.visible) continue;
+      const value = content.get(e.id) ?? "";
+      if (e.data.label === void 0 && value) e.data.label = value;
+      content.set(e.parent, value + (content.get(e.parent) ?? ""));
+    }
+  };
+}
+export {
+  installTextSemantics
+};

package/modules/a11y/core/tree.d.ts

@@ -0,0 +1,2 @@
+import type { SemanticNode } from './types.js';
+export declare const flat: (tree: SemanticNode[]) => SemanticNode[];

package/modules/a11y/core/tree.js

@@ -0,0 +1,4 @@
+const flat = (tree) => tree.flatMap((n) => [n, ...flat(n.children)]);
+export {
+  flat
+};

package/modules/a11y/core/types.d.ts

@@ -0,0 +1,72 @@
+/** Shared core/host/overlay contract. Coordinates are world grid units. */
+export type SemanticAction = 'tap' | 'increase' | 'decrease' | 'focus';
+export interface SemanticNode {
+    id: string;
+    role: string;
+    label?: string;
+    hint?: string;
+    value?: string | number;
+    valueText?: string;
+    level?: number;
+    href?: string;
+    controls?: string;
+    states: {
+        checked?: boolean | 'mixed';
+        pressed?: boolean;
+        selected?: boolean;
+        expanded?: boolean;
+        disabled?: boolean;
+        required?: boolean;
+        readonly?: boolean;
+        modal?: boolean;
+        focused?: boolean;
+        live?: 'polite' | 'assertive';
+    };
+    min?: number;
+    max?: number;
+    step?: number;
+    bounds: [number, number, number, number];
+    actions: SemanticAction[];
+    children: SemanticNode[];
+}
+export interface SemanticDiff {
+    added: string[];
+    removed: string[];
+    changed: {
+        id: string;
+        keys: string[];
+    }[];
+}
+export interface A11yConfig {
+    role: string;
+    label?: string;
+    hint?: string;
+    value?: string;
+    valueText?: string;
+    level?: number | string;
+    href?: string;
+    controls?: string;
+    checked?: boolean | string;
+    checkedMixed?: boolean | string;
+    pressed?: boolean | string;
+    selected?: boolean | string;
+    expanded?: boolean | string;
+    disabled?: boolean | string;
+    hidden?: boolean | string;
+    required?: boolean | string;
+    readonly?: boolean | string;
+    modal?: boolean | string;
+    live?: 'off' | 'polite' | 'assertive';
+    activate?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    bounds?: [number, number, number, number];
+}
+declare module '../../../packages/core/src/player.ts' {
+    interface Player {
+        semantics(): SemanticNode[];
+        semanticDiff(previous: SemanticNode[], next: SemanticNode[]): SemanticDiff;
+        semanticAction(id: string, action: SemanticAction): boolean;
+    }
+}

package/modules/a11y/core/validate.d.ts

@@ -0,0 +1,4 @@
+import type { Model } from '../../../packages/core/src/load.js';
+import type { Diags } from '../../../packages/core/src/diag.js';
+export declare const allowed: Record<string, string>;
+export declare function validate(model: Model, d: Diags): void;

package/modules/a11y/core/validate.js

@@ -0,0 +1,91 @@
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { states } from "./registry.js";
+const allowed = {
+  checked: "checkbox switch radio",
+  pressed: "button",
+  selected: "tab list-item radio",
+  expanded: "button link group list-item",
+  required: "checkbox switch radio radio-group slider",
+  readonly: "checkbox switch slider",
+  modal: "dialog alert-dialog"
+};
+function validate(model, d) {
+  const visit = (nodes, base) => nodes.forEach((n, i) => {
+    const p = base + "/" + i;
+    if (n.children) visit(n.children, p + "/children");
+    const c = n.a11y;
+    if (!c) return;
+    const err = (code, key, message, hint) => d.err(code, p + "/a11y/" + key, V && message, V && hint);
+    for (const [k, v] of Object.entries(c)) {
+      const input = typeof v === "string" && model.inputs.get(v);
+      const numeric = k === "level" || k === "value" && ["slider", "progressbar", "meter"].includes(c.role);
+      const binding = states.includes(k) || k === "checkedMixed" || k === "activate" || numeric;
+      const text = "label hint value valueText".split(" ").includes(k);
+      if (typeof v === "string" && (binding || text && (v.startsWith("$") || input))) {
+        if (v.startsWith("$") && !model.doc.requires?.includes("data"))
+          err(
+            "undeclared-feature",
+            k,
+            "data binding needs data",
+            'add "data" to requires and load the data module'
+          );
+        else if (!input)
+          err("unknown-input", k, "unknown semantic input", "name a declared input or data path");
+        else if (!(k === "activate" ? ["bool", "trigger"] : states.includes(k) || k === "checkedMixed" ? ["bool"] : numeric ? ["number"] : ["string"]).includes(input.type))
+          err(
+            "input-type",
+            k,
+            "semantic input has the wrong type",
+            V && "use " + (k === "activate" ? "bool or trigger" : binding ? numeric ? "number" : "bool" : "string")
+          );
+        const warning = d.list.findIndex(
+          (e) => e.code === "unused-input" && e.pointer === "/inputs/" + v
+        );
+        if (warning >= 0) d.list.splice(warning, 1);
+      }
+      if (allowed[k] && !allowed[k].split(" ").includes(c.role))
+        err(
+          "a11y-role-state",
+          k,
+          "state is not supported by this role",
+          V && "allowed states: " + [
+            ...states.filter((s) => !allowed[s] || allowed[s].split(" ").includes(c.role)),
+            ...c.role === "checkbox" ? ["checkedMixed"] : []
+          ].join(", ")
+        );
+    }
+    for (const [keys, role] of [
+      ["valueText min max", "slider progressbar meter"],
+      ["step", "slider"],
+      ["level", "heading"],
+      ["href", "link"],
+      ["checkedMixed", "checkbox"]
+    ])
+      for (const key of keys.split(" "))
+        if (c[key] !== void 0 && !role.split(" ").includes(c.role))
+          err(
+            "bad-value",
+            key,
+            key + " requires " + role,
+            'use role "' + role + '" or omit ' + key
+          );
+    if (["slider", "meter"].includes(c.role) && !c.value)
+      err("bad-value", "value", "role needs a bound number", "name a number input or data path");
+    if (c.controls !== void 0 && !model.nodes.some(
+      (node) => node.id !== n.id && node.id === c.controls && node.raw.a11y && node.raw.a11y.role !== "none"
+    ))
+      err(
+        "bad-value",
+        "controls",
+        "controls needs a semantic node id",
+        "name a node with a non-none a11y role in this component"
+      );
+    if ((c.min ?? 0) >= (c.max ?? 100))
+      err("bad-value", "min", "min must be less than max", "set min below max");
+  });
+  visit(model.doc.nodes, "/nodes");
+}
+export {
+  allowed,
+  validate
+};

package/modules/a11y/manifest.d.ts

@@ -0,0 +1,51 @@
+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;
+        over?: undefined;
+        authoring?: undefined;
+    } | {
+        name: string;
+        budget: number;
+        over: string;
+        authoring?: undefined;
+    } | {
+        name: string;
+        budget: number;
+        over: string;
+        authoring: boolean;
+    })[];
+    adapters: {
+        'packages/core/src/modules/a11y/index.ts': string;
+        'packages/core/src/modules/a11y/svg.ts': string;
+        'packages/markup/src/a11y.ts': string;
+        'packages/web/src/a11y.ts': string;
+        'packages/web/src/a11y-text.ts': string;
+        'packages/web/src/a11y-bounds.ts': string;
+        'packages/core/src/modules/a11y/text.ts': string;
+        'packages/web/src/markup-a11y.ts': string;
+    };
+    exports: {
+        'core:./a11y': string;
+        'markup:./a11y': string;
+        'core:./a11y-text': string;
+        'web:./a11y-text': string;
+        'web:./a11y-bounds': string;
+        'web:./a11y': string;
+        'web:./markup-a11y': string;
+    };
+    tests: string[];
+    conformance: string[];
+    docs: string[];
+};
+export default _default;

package/modules/a11y/manifest.js

@@ -0,0 +1,51 @@
+const after = ["data", "focus", "lists"];
+var manifest_default = {
+  ...{
+    name: "a11y",
+    summary: "Accessible names, roles, values and states for nodes, with a headless semantic tree for tools and tests.",
+    after: [],
+    core: { entry: "core/index.ts", export: "a11y", svg: "core/svg.ts", svgExport: "a11ySVG" },
+    web: [
+      { name: "a11y", budget: 2496 },
+      { name: "a11y-text", budget: 576, over: "a11y" },
+      { name: "a11y-bounds", budget: 4096, over: "a11y" },
+      { name: "markup-a11y", budget: 1088, over: "index", authoring: true }
+    ],
+    adapters: {
+      "packages/core/src/modules/a11y/index.ts": "core/index.ts",
+      "packages/core/src/modules/a11y/svg.ts": "core/svg.ts",
+      "packages/markup/src/a11y.ts": "markup/index.ts",
+      "packages/web/src/a11y.ts": "web/index.ts",
+      "packages/web/src/a11y-text.ts": "web/text.ts",
+      "packages/web/src/a11y-bounds.ts": "web/bounds.ts",
+      "packages/core/src/modules/a11y/text.ts": "core/text.ts",
+      "packages/web/src/markup-a11y.ts": "web/markup.ts"
+    },
+    exports: {
+      "core:./a11y": "packages/core/src/modules/a11y/index.ts",
+      "markup:./a11y": "packages/markup/src/a11y.ts",
+      "core:./a11y-text": "packages/core/src/modules/a11y/text.ts",
+      "web:./a11y-text": "packages/web/src/a11y-text.ts",
+      "web:./a11y-bounds": "packages/web/src/a11y-bounds.ts",
+      "web:./a11y": "packages/web/src/a11y.ts",
+      "web:./markup-a11y": "packages/web/src/markup-a11y.ts"
+    },
+    tests: [
+      "modules/a11y/test/**/*.test.ts",
+      "packages/markup/test/corpus.test.ts",
+      "packages/markup/test/names.test.ts"
+    ],
+    conformance: ["a11y-", "a11y-inferred-text", "a11y-tree-bounds"],
+    docs: [
+      "spec/SPEC.md",
+      "modules/a11y/SPEC.md",
+      "modules/a11y/AUTHORING.md",
+      "modules/a11y/TEXT.md"
+    ]
+  },
+  after
+};
+export {
+  after,
+  manifest_default as default
+};

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

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

package/modules/a11y/markup/index.js

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

package/modules/a11y/web/bounds.d.ts

@@ -0,0 +1 @@
+import './index.js';

package/modules/a11y/web/bounds.js

@@ -0,0 +1,31 @@
+import "./index.js";
+import { installPaintedBounds, boundsScales } from "../core/bounds.js";
+const Icon = customElements.get("anima-icon");
+const runtime = Icon.modules.get("a11y").runtime;
+installPaintedBounds(runtime, Icon.modules);
+const previous = Icon.eventHook;
+const observers = /* @__PURE__ */ new WeakMap();
+Icon.eventHook = (icon, kind, detail) => {
+  if (kind === "cleanup") {
+    observers.get(icon)?.disconnect();
+    observers.delete(icon);
+  }
+  if (kind === "draw" && icon.player?.model.doc.requires?.includes("a11y")) {
+    const p = icon.player;
+    if (!observers.has(icon) && icon.isConnected) {
+      const observer = new ResizeObserver(() => icon.invalidate());
+      observer.observe(icon);
+      observers.set(icon, observer);
+    }
+    const c = Icon.canvasBox?.(icon, [0, 0, 1, 1]);
+    const m = icon.shadowRoot.querySelector("svg")?.getScreenCTM();
+    const scale = c ? [c.width, c.height] : m ? [m.a, m.d] : [1, 1];
+    if (scale.every((s) => s > 0) && String(boundsScales.get(p)) !== String(scale)) {
+      boundsScales.set(p, scale);
+      runtime.caches.delete(p);
+      queueMicrotask(() => icon.invalidate());
+    }
+  }
+  previous?.(icon, kind, detail);
+};
+for (const icon of document.querySelectorAll("anima-icon")) icon.invalidate();

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

@@ -0,0 +1 @@
+import '../../../packages/web/src/index.js';

package/modules/a11y/web/index.js

@@ -0,0 +1,3 @@
+import { a11y } from "../core/index.js";
+import "../../../packages/web/src/index.js";
+customElements.get("anima-icon").registerModule(a11y);

package/modules/a11y/web/markup.d.ts

@@ -0,0 +1 @@
+import '../../../packages/web/src/index.js';

package/modules/a11y/web/markup.js

@@ -0,0 +1,3 @@
+import { a11yMarkup } from "../markup/index.js";
+import "../../../packages/web/src/index.js";
+customElements.get("anima-icon").registerMarkup("paint", a11yMarkup);

package/modules/a11y/web/text.d.ts

@@ -0,0 +1 @@
+import './index.js';

package/modules/a11y/web/text.js

@@ -0,0 +1,6 @@
+import "./index.js";
+import { installTextSemantics } from "../core/text.js";
+const Icon = customElements.get("anima-icon");
+installTextSemantics(Icon.modules.get("a11y").runtime, Icon.modules);
+for (const icon of document.querySelectorAll("anima-icon"))
+  icon.attributeChangedCallback("renderer", null, icon.getAttribute("renderer"));