animl 0.0.0-stage → 0.1.0

package/packages/markup/src/compile.js

@@ -0,0 +1,747 @@
+import {
+  NAME,
+  PAINT,
+  ELEMENTS,
+  NODE_TYPES,
+  nodeShape,
+  VERBOSE,
+  formatAni,
+  load,
+  parseHex,
+  suggest,
+  ptr
+} from "animl";
+import { libraryCompiler, location } from "./library-hooks.js";
+import {
+  animationCompiler,
+  moduleCompiler,
+  textCompiler,
+  componentCompiler,
+  bindCompiler,
+  motionCompiler,
+  eventsCompiler,
+  dataCompiler,
+  convertCompiler
+} from "./module-hooks.js";
+import { elementFields, compoundField } from "./fields.js";
+import { componentMarkup } from "./components.js";
+import { aniAddress, nodeFields } from "./names.js";
+import { parseXml } from "./xml.js";
+const NODES = NODE_TYPES;
+const BUILTINS = "linear hold in out inOut".split(" ");
+const FORMS = {
+  anima: {
+    attrs: {
+      version: "string",
+      name: "string",
+      title: "string",
+      grid: "number",
+      viewBox: 4,
+      requires: "names",
+      xmlns: "string"
+    },
+    required: ["version", "name", "grid"],
+    children: [
+      "meta",
+      "color",
+      "glyph",
+      "asset",
+      "a11y",
+      "bool",
+      "number",
+      "trigger",
+      "hit",
+      ...NODES,
+      "ease",
+      "timeline",
+      "layer",
+      "listener",
+      "bind",
+      "component"
+    ]
+  },
+  meta: { attrs: {} },
+  color: { attrs: { name: "name", value: "color" }, required: ["name", "value"] },
+  glyph: {
+    attrs: { name: "name", d: "string", source: "string", pick: "string", sha256: "string" },
+    required: ["name", "d"]
+  },
+  a11y: {
+    attrs: { role: "string", label: "string", activate: "name", pressed: "name", held: "name" }
+  },
+  bool: { attrs: { name: "name", default: "boolean" }, required: ["name"] },
+  number: {
+    attrs: { name: "name", default: "number", min: "number", max: "number" },
+    required: ["name"]
+  },
+  trigger: { attrs: { name: "name", buffer: "number" }, required: ["name"] },
+  hit: { attrs: { circle: 3, rect: 4 } },
+  ease: { attrs: { name: "name", curve: "ease" }, required: ["name", "curve"] },
+  timeline: {
+    attrs: { name: "name", colorSpace: "string" },
+    required: ["name", "duration"],
+    children: ["track", "event"]
+  },
+  track: { attrs: { target: "string" }, required: ["target"] },
+  event: { attrs: { at: "number", name: "name" }, required: ["at", "name"] },
+  layer: {
+    attrs: { name: "name", mode: "string" },
+    required: ["name", "initial"],
+    children: ["state"]
+  },
+  state: { attrs: { name: "name" }, required: ["name"], children: ["pose", "on"] },
+  pose: { attrs: {} },
+  on: { attrs: {}, required: ["when", "to"] },
+  listener: { attrs: {}, required: ["on"] }
+};
+if (VERBOSE)
+  FORMS.component = componentMarkup.componentForm({ name: "component" }, FORMS.anima);
+const NAMED = {
+  color: "colors",
+  glyph: "glyphs",
+  asset: "assets",
+  component: "components",
+  bool: "inputs",
+  number: "inputs",
+  trigger: "inputs",
+  timeline: "timelines",
+  layer: "layers"
+};
+const IS_NUMBER = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+const object = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+const own = (o, k, v) => Object.defineProperty(o, k, { value: v, enumerable: true, configurable: true, writable: true });
+class Compiler {
+  elements = ELEMENTS;
+  builtins = BUILTINS;
+  diagnostics = [];
+  map = /* @__PURE__ */ new Map();
+  types = /* @__PURE__ */ new Map();
+  // Registry descriptors are stable during one compile. Reuse them for nodes and addresses,
+  // but start fresh next time so modules registered between compiles are always visible.
+  // seam(P7-2): node and structural elements take disjoint branches; share their field cache.
+  fieldIndex = /* @__PURE__ */ new Map();
+  fields(name) {
+    let fields = this.fieldIndex.get(name);
+    if (!fields) this.fieldIndex.set(name, fields = elementFields(name));
+    return fields;
+  }
+  nodeAttrs = (type) => {
+    let attrs = this.fieldIndex.get(type);
+    if (!attrs) this.fieldIndex.set(type, attrs = nodeFields(type));
+    return attrs;
+  };
+  eases = /* @__PURE__ */ new Map();
+  resolved = /* @__PURE__ */ new Map();
+  resolving = /* @__PURE__ */ new Set();
+  finalEases = [];
+  xml;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  error(code, p, at, message, hint) {
+    this.diagnostics.push({
+      code,
+      severity: "error",
+      pointer: p,
+      message: VERBOSE ? message : code,
+      ...VERBOSE && hint ? { hint } : {},
+      line: at.line,
+      column: at.col,
+      file: at.file ?? this.opts.file,
+      ...at.related ? { related: [location(at.related)] } : {}
+    });
+  }
+  unavailable(feature, entry, p, at) {
+    const hint = `load @anima-format/web/${entry} or run anima build`;
+    this.diagnostics.push({
+      code: `markup-${feature}-unavailable`,
+      severity: "error",
+      pointer: p,
+      message: hint,
+      hint,
+      file: at.file ?? this.opts.file,
+      line: at.line,
+      column: at.col
+    });
+  }
+  get failed() {
+    return this.diagnostics.some((d) => d.severity === "error");
+  }
+  // All values, including generated containers and vector entries, get an origin. A later, more
+  // specific write (e.g. a keyframe token) overrides the container's default position.
+  mark(p, value, at) {
+    this.map.set(p, at);
+    if (value !== null && typeof value === "object")
+      for (const [k, v] of Object.entries(value)) this.mark(ptr(p, k), v, at);
+  }
+  put(o, key, value, p, at) {
+    own(o, key, value);
+    this.mark(ptr(p, key), value, at);
+  }
+  container(o, key, p, at) {
+    if (!Object.hasOwn(o, key)) this.put(o, key, {}, p, at);
+    return o[key];
+  }
+  append(o, key, p, at) {
+    if (!Object.hasOwn(o, key)) this.put(o, key, [], p, at);
+    const a = o[key];
+    return [a, ptr(ptr(p, key), a.length)];
+  }
+  address(s) {
+    return aniAddress(s, (id) => this.types.get(id), this.nodeAttrs) ?? s;
+  }
+  forms = /* @__PURE__ */ new WeakMap();
+  form(el) {
+    let form = this.forms.get(el);
+    if (!form) this.forms.set(el, form = this.formFor(el));
+    return form;
+  }
+  formFor(el) {
+    if (NODES.includes(el.name)) {
+      const ns = nodeShape(el.name), attrs = { id: "name" };
+      const required = ["id"];
+      for (const a of this.nodeAttrs(el.name)) {
+        attrs[a.attr] = a.index === void 0 ? this.kind(a.shape) : "number";
+        if ((el.name === "circle" || el.name === "arc") && ["cx", "cy", "r"].includes(a.attr))
+          required.push(a.attr);
+        if (el.name === "arc" && ["from", "to"].includes(a.attr)) required.push(a.attr);
+        if (el.name === "rect" && ["x0", "y0", "width", "height"].includes(a.attr))
+          required.push(a.attr);
+      }
+      componentCompiler.form?.(el, attrs, required);
+      let base2 = {
+        attrs,
+        required,
+        children: [
+          ...ns.p.children ? NODES : [],
+          ...(moduleCompiler.nodes?.(this) ?? []).filter(
+            (key) => Object.hasOwn(ns.p, this.elements[key].target.default)
+          )
+        ]
+      };
+      base2 = motionCompiler.form?.(el, base2) ?? base2;
+      return dataCompiler.form?.(el, eventsCompiler.form?.(el, base2) ?? base2) ?? base2;
+    }
+    let base = moduleCompiler.form?.(this, el) ?? componentCompiler.componentForm?.(el, FORMS.anima) ?? FORMS[el.name];
+    if (base) {
+      const attrs = { ...base.attrs };
+      for (const f of this.fields(el.name)) {
+        if (f.attr !== f.key) Reflect.deleteProperty(attrs, f.key);
+        attrs[f.attr] = f.key === "when" ? "condition" : f.key === "ease" ? "ease" : ["fire", "toggle"].includes(f.key) ? "names" : f.key === "set" ? "set" : compoundField(f.shape) ? "json" : this.kind(f.shape);
+      }
+      base = { ...base, attrs };
+    }
+    for (const hooks of [motionCompiler, eventsCompiler, convertCompiler, dataCompiler])
+      base = hooks.form?.(el, base ?? { attrs: {} }) ?? base;
+    return base;
+  }
+  kind(s) {
+    if (s.k === "alt" && s.of.some((s2) => s2.k === "str")) return "mixed";
+    if (s.k === "obj" || s.k === "map" || s.k === "any" || s.k === "alt") return "json";
+    if (s.k === "num") return "number";
+    if (s.k === "bool") return "boolean";
+    if (s.k === "tup") return s.of.length;
+    if (s.k === "arr") return s.of.k === "alt" ? "lengths" : "indices";
+    return s.k === "str" && s.re === NAME ? "name" : "string";
+  }
+  attrs(el, p) {
+    const form = this.form(el);
+    const out = /* @__PURE__ */ new Map();
+    for (const a of el.attrs) {
+      if (out.has(a.name))
+        this.error(
+          "duplicate-attribute",
+          p,
+          a.at,
+          VERBOSE ? `attribute "${a.name}" appears twice` : ""
+        );
+      else out.set(a.name, a);
+      if (el.name !== "pose" && !Object.hasOwn(form.attrs, a.name))
+        this.error(
+          "unknown-attribute",
+          p,
+          a.at,
+          VERBOSE ? `<${el.name}> takes no "${a.name}" attribute` : "",
+          VERBOSE ? suggest(a.name, Object.keys(form.attrs)) : ""
+        );
+    }
+    for (const name of form.required ?? [])
+      if (!out.has(name))
+        this.error(
+          "missing-attribute",
+          p,
+          el.at,
+          VERBOSE ? `<${el.name}> needs "${name}"` : "",
+          VERBOSE ? `add ${name}="\u2026"` : ""
+        );
+    return out;
+  }
+  children(el, p) {
+    const out = [];
+    const allowed = [
+      ...this.form(el).children ?? [],
+      ...el.name === "anima" ? Object.keys(this.elements).filter((k) => this.elements[k].root) : []
+    ];
+    for (const c of el.children) {
+      if (c.kind === "text" && c.value.trim() && !["track", "meta"].includes(el.name))
+        this.error(
+          "markup-syntax",
+          p,
+          c.at,
+          VERBOSE ? `text is not allowed inside <${el.name}>` : ""
+        );
+      if (c.kind !== "element") continue;
+      const dataInstance = c.name === "instance" && !!dataCompiler.form?.(c, { attrs: {} }).attrs.model;
+      if (!VERBOSE) {
+        const feature = ["component", "instance"].includes(c.name) && !dataInstance && !componentCompiler.enter ? "components" : c.name === "bind" && !bindCompiler.build ? "bind" : !moduleCompiler.node && ELEMENTS[c.name]?.target && !(textCompiler.node && (ELEMENTS[c.name].target.mapKey || ELEMENTS[c.name].target.array && !ELEMENTS[c.name].target.wrapper)) ? "paint" : void 0;
+        if (feature) {
+          this.unavailable(feature, feature === "paint" ? "markup-paint" : feature, p, c.at);
+        }
+        if (feature) continue;
+      }
+      if (!NODES.includes(c.name) && !Object.hasOwn(FORMS, c.name) && c.name !== "component" && !(["event-def", "audio-volume"].includes(c.name) && eventsCompiler.form) && !((["model", "enum", "string", "list", "model-ref", "asset-ref", "set"].includes(c.name) || dataInstance) && dataCompiler.form) && !(["channel", "machine"].includes(c.name) && motionCompiler.form) && !Object.hasOwn(ELEMENTS, c.name))
+        this.error(
+          "unknown-element",
+          p,
+          c.at,
+          VERBOSE ? `unknown element <${c.name}>` : "",
+          VERBOSE ? suggest(c.name, [...Object.keys(FORMS), ...NODES]) : ""
+        );
+      else if (!allowed.includes(c.name) && !(["anima", "component"].includes(el.name) && NODES.includes(c.name)))
+        this.error(
+          "misplaced-element",
+          p,
+          c.at,
+          VERBOSE ? `<${c.name}> is not allowed inside <${el.name}>` : "",
+          VERBOSE ? suggest(c.name, allowed) : ""
+        );
+      else out.push(c);
+    }
+    return out;
+  }
+  comment(el, o, p) {
+    for (const c of el.children) {
+      if (c.kind === "element") break;
+      if (c.kind === "comment") {
+        this.put(o, "$comment", c.value.trim(), p, c.at);
+        break;
+      }
+    }
+  }
+  num(s) {
+    const value = Number(s);
+    if (!IS_NUMBER.test(s) || !Number.isFinite(value))
+      throw new Error(VERBOSE ? "expected a finite JSON number" : "");
+    return value;
+  }
+  color(s) {
+    if (NAME.test(s) || parseHex(s)) return s;
+    throw new Error(VERBOSE ? "expected a colour literal or slot name" : "");
+  }
+  scalar(s, color = true) {
+    if (s.startsWith('"')) return JSON.parse(s);
+    if (s === "true" || s === "false") return s === "true";
+    if (IS_NUMBER.test(s)) return this.num(s);
+    if (color && (NAME.test(s) || parseHex(s))) return s;
+    throw new Error(
+      VERBOSE ? color ? "expected a number, boolean or colour" : "expected a number or boolean" : ""
+    );
+  }
+  read(a, kind, p) {
+    const s = a.value.trim();
+    try {
+      if (typeof kind === "number") {
+        const parts = s.split(/\s*,\s*|\s+/);
+        if (parts.some((x) => !IS_NUMBER.test(x)))
+          throw new Error(VERBOSE ? "expected numbers separated by whitespace or one comma" : "");
+        const v = parts.map((x) => this.num(x));
+        if (kind && v.length !== kind) throw new Error(VERBOSE ? `expected ${kind} numbers` : "");
+        return v;
+      }
+      switch (kind) {
+        case "json":
+          return JSON.parse(s);
+        case "number":
+          return this.num(s);
+        case "boolean":
+          if (s !== "true" && s !== "false")
+            throw new Error(VERBOSE ? "expected true or false" : "");
+          return s === "true";
+        case "name":
+          if (!NAME.test(s))
+            throw new Error(VERBOSE ? "expected a name matching [a-z][a-zA-Z0-9-]*" : "");
+          return s;
+        case "value":
+          return this.scalar(s);
+        case "color":
+          return this.color(s);
+        case "lengths":
+          return moduleCompiler.lengths?.(this, s);
+        case "indices":
+          if (!s) throw new Error(VERBOSE ? "expected a whitespace-separated index list" : "");
+          return s.split(/\s+/).map((x) => this.num(x));
+        case "names": {
+          const v = s ? s.split(/\s+/) : [];
+          if (a.name !== "requires" && (!v.length || v.some(
+            (x) => !NAME.test(x) && !(["fire", "toggle"].includes(a.name) && /^(?:\$[\w-]+:)?\$?[a-zA-Z][\w-]*(?:\.[\w-]+)*$/.test(x))
+          )))
+            throw new Error(VERBOSE ? "expected a whitespace-separated name list" : "");
+          return v;
+        }
+        case "set":
+        case "ease":
+        case "condition":
+          if (!animationCompiler.read)
+            this.unavailable("animation", "markup-animation", p, a.valueAt);
+          return animationCompiler.read?.(this, s, kind);
+        case "mixed":
+          try {
+            return JSON.parse(s);
+          } catch {
+            return a.value;
+          }
+        case "string":
+          return a.value;
+      }
+    } catch (e) {
+      this.error(
+        "bad-attribute",
+        p,
+        a.valueAt,
+        VERBOSE ? e instanceof Error ? e.message : "invalid attribute value" : "",
+        a.name === "grid" ? 'grid is one number (units per side); use viewBox="0 0 40 30" for a rectangular scene' : void 0
+      );
+      return void 0;
+    }
+  }
+  copy(el, a, o, p, omit = []) {
+    for (const [name, attr] of a) {
+      if (omit.includes(name) || !Object.hasOwn(this.form(el).attrs, name)) continue;
+      const key = name === "version" ? "anima" : this.fields(el.name).find((f) => f.attr === name)?.key ?? name;
+      let v = this.read(attr, this.form(el).attrs[name], ptr(p, key));
+      if ((name === "fire" || name === "toggle") && Array.isArray(v) && v.length === 1) v = v[0];
+      if (v !== void 0) this.put(o, key, v, p, attr.valueAt);
+    }
+  }
+  addNamed(o, key, el, p, at) {
+    if (Object.hasOwn(o, key)) {
+      this.error(
+        "duplicate-name",
+        ptr(p, key),
+        at,
+        VERBOSE ? `"${key}" is declared twice in this map` : ""
+      );
+      return false;
+    }
+    own(o, key, this.build(el, ptr(p, key)));
+    return true;
+  }
+  build(el, p) {
+    this.map.set(p, el.at);
+    if (p === "/a11y") this.forms.set(el, FORMS.a11y);
+    const a = this.attrs(el, p);
+    const children = this.children(el, p);
+    const o = {};
+    const leave = componentCompiler.enter?.(this, el, children, p);
+    if (!["track", "event", "color", "ease"].includes(el.name)) this.comment(el, o, p);
+    if (NODES.includes(el.name)) {
+      this.copyNode(el, a, o, p);
+      const rest = textCompiler.node?.(this, el, children, o, p) ?? children;
+      moduleCompiler.node?.(this, el, rest, o, p);
+      componentCompiler.node?.(this, el, a, o, p);
+      motionCompiler.node?.(this, el, children, o, p);
+      dataCompiler.node?.(el, o);
+      if (nodeShape(el.name).p.children) {
+        const list = [];
+        this.put(o, "children", list, p, el.at);
+        for (const c of children)
+          if (NODES.includes(c.name)) list.push(this.build(c, ptr(p + "/children", list.length)));
+      }
+    } else if (el.name === "bind") {
+      return dataCompiler.binding?.(a) ?? bindCompiler.build?.(a);
+    } else if (ELEMENTS[el.name] && p !== "/a11y") {
+      moduleCompiler.build?.(this, el, a, children, o, p);
+    } else if (el.name === "track") {
+      this.map.set(p, a.get("target")?.valueAt ?? el.at);
+      const keys = motionCompiler.frames?.(this, el, children, p) ?? animationCompiler.frames?.(this, el, p, motionCompiler.keyValue);
+      if (!keys) {
+        this.unavailable("animation", "markup-animation", p, el.at);
+        return [];
+      }
+      if (keys.length && keys.at(-1).length === 3)
+        this.finalEases.push({
+          key: keys.at(-1),
+          pointer: ptr(p, keys.length - 1) + "/2"
+        });
+      return keys;
+    } else if (el.name === "event") {
+      const v = [
+        a.has("at") ? this.read(a.get("at"), "number", p + "/0") : 0,
+        a.get("name")?.value.trim() ?? ""
+      ];
+      this.mark(p + "/0", v[0], a.get("at")?.valueAt ?? el.at);
+      this.mark(p + "/1", v[1], a.get("name")?.valueAt ?? el.at);
+      if (a.has("name")) this.read(a.get("name"), "name", p + "/1");
+      return v;
+    } else if (el.name === "meta") {
+      const text = el.children.filter((c) => c.kind === "text").map((c) => c.value).join("");
+      try {
+        const v = JSON.parse(text);
+        if (!object(v)) throw new Error(VERBOSE ? "meta must contain a JSON object" : "");
+        this.mark(p, v, el.at);
+        this.comment(el, v, p);
+        return v;
+      } catch (e) {
+        this.error(
+          "bad-attribute",
+          p,
+          el.children.find((c) => c.kind === "text")?.at ?? el.at,
+          VERBOSE ? e instanceof Error ? e.message : "invalid JSON metadata" : ""
+        );
+      }
+    } else if (el.name === "color") {
+      if (a.has("name")) this.read(a.get("name"), "name", p);
+      const v = a.has("value") ? this.read(a.get("value"), "color", p) : "";
+      this.map.set(p, a.get("value")?.valueAt ?? el.at);
+      return v;
+    } else if (el.name === "pose") {
+      for (const attr of a.values()) {
+        const key = this.address(attr.name);
+        const v = this.read(attr, key.endsWith(".d") ? "string" : "value", ptr(p, key));
+        if (v !== void 0) this.put(o, key, v, p, attr.valueAt);
+      }
+    } else {
+      this.copy(el, a, o, p, ["name", "xmlns"]);
+      if (a.has("name") && el.name !== "anima" && el.name !== "component")
+        this.read(a.get("name"), "name", p);
+      if (el.name === "anima" || el.name === "component") {
+        if (el.name === "anima" && a.has("name"))
+          this.put(o, "name", a.get("name").value, p, a.get("name").valueAt);
+        this.put(o, "nodes", [], p, el.at);
+        for (const c of children) this.rootChild(c, o, p);
+      } else if (["bool", "number", "trigger"].includes(el.name))
+        this.put(o, "type", el.name, p, el.at);
+      else if (el.name === "hit") {
+        if (Number(a.has("circle")) + Number(a.has("rect")) !== 1)
+          this.error(
+            a.size ? "bad-attribute" : "missing-attribute",
+            p,
+            el.at,
+            VERBOSE ? "<hit> needs exactly one of circle or rect" : ""
+          );
+      } else if (el.name === "timeline" || el.name === "layer") {
+        const key = el.name === "timeline" ? "tracks" : "states";
+        this.put(o, key, {}, p, el.at);
+        for (const c of children) {
+          if (c.name === "event") {
+            const [events, ep] = this.append(o, "events", p, c.at);
+            events.push(this.build(c, ep));
+          } else {
+            const name = c.attrs.find((a2) => a2.name === (key === "tracks" ? "target" : "name"));
+            const value = name?.value.trim() ?? "";
+            this.addNamed(
+              o[key],
+              key === "tracks" ? this.address(value) : value,
+              c,
+              p + "/" + key,
+              name?.valueAt ?? c.at
+            );
+          }
+        }
+      } else if (el.name === "state") {
+        if (!a.has("play")) this.put(o, "pose", {}, p, el.at);
+        let pose = false;
+        let on = false;
+        for (const c of children) {
+          if (c.name === "pose") {
+            if (pose || on)
+              this.error(
+                "misplaced-element",
+                p + "/pose",
+                c.at,
+                VERBOSE ? "<pose> may occur once, before any <on>" : ""
+              );
+            else own(o, "pose", this.build(c, p + "/pose"));
+            pose = true;
+          } else {
+            on = true;
+            const [list, op] = this.append(o, "on", p, c.at);
+            list.push(this.build(c, op));
+          }
+        }
+      }
+    }
+    if (el.name === "asset") delete o.name;
+    leave?.();
+    return o;
+  }
+  rootChild(c, o, p) {
+    const name = c.attrs.find((a) => a.name === "name");
+    for (const hooks of [
+      convertCompiler,
+      dataCompiler,
+      eventsCompiler,
+      bindCompiler,
+      motionCompiler,
+      textCompiler
+    ])
+      if (hooks.rootChild?.(this, c, o, p)) return;
+    if (c.name === "ease") {
+      this.attrs(c, p);
+      this.children(c, p);
+      return;
+    }
+    if (NODES.includes(c.name) || c.name === "listener") {
+      const [list, cp] = this.append(o, c.name === "listener" ? "listeners" : "nodes", p, c.at);
+      list.push(this.build(c, cp));
+    } else if (Object.hasOwn(NAMED, c.name)) {
+      const key = NAMED[c.name];
+      const parent = key === "layers" ? this.container(o, "machine", p, c.at) : o;
+      const base = key === "layers" ? p + "/machine" : p;
+      const map = this.container(parent, key, base, c.at);
+      this.addNamed(map, name?.value.trim() ?? "", c, ptr(base, key), name?.valueAt ?? c.at);
+    } else if (Object.hasOwn(o, c.name))
+      this.error(
+        "misplaced-element",
+        ptr(p, c.name),
+        c.at,
+        VERBOSE ? `<${c.name}> may occur only once` : ""
+      );
+    else own(o, c.name, this.build(c, ptr(p, c.name)));
+  }
+  copyNode(el, attrs, o, p) {
+    this.put(o, "type", el.name, p, el.at);
+    const id = attrs.get("id");
+    if (id) this.put(o, "id", this.read(id, "name", p + "/id"), p, id.valueAt);
+    for (const a of this.nodeAttrs(el.name)) {
+      const attr = attrs.get(a.attr);
+      if (!attr) continue;
+      const paint = a.path[1] && a.path[0];
+      if (paint && paint in PAINT && a.path[1] !== "color" && !attrs.has(paint) && !moduleCompiler.hasPaint?.(this, el, paint))
+        this.error(
+          "paint-attribute",
+          ptr(p, paint),
+          attr.valueAt,
+          VERBOSE ? `"${attr.name}" needs "${paint}"` : "",
+          VERBOSE ? `add ${paint}="\u2026"` : ""
+        );
+      const v = this.read(
+        attr,
+        a.index !== void 0 ? "number" : a.path[1] === "color" ? "color" : this.kind(a.shape),
+        a.path.reduce(ptr, p)
+      );
+      if (v === void 0) continue;
+      if (a.index !== void 0) {
+        if (!Object.hasOwn(o, a.path[0])) this.put(o, a.path[0], [], p, attr.valueAt);
+        o[a.path[0]][a.index] = v;
+        this.map.set(ptr(ptr(p, a.path[0]), a.index), attr.valueAt);
+      } else
+        this.put(
+          paint ? this.container(o, paint, p, attr.valueAt) : o,
+          a.path.at(-1),
+          v,
+          paint ? ptr(p, paint) : p,
+          attr.valueAt
+        );
+    }
+  }
+  collectTypes(el, scoped = false) {
+    if (NODES.includes(el.name)) {
+      const id = el.attrs.find((a) => a.name === "id");
+      if (id) this.types.set(scoped ? id.value : id.value.trim(), el.name);
+    }
+    for (const c of el.children)
+      if (c.kind === "element" && (scoped || c.name !== "component")) this.collectTypes(c, scoped);
+  }
+  collectEases(el, p) {
+    if (animationCompiler.collectEases) animationCompiler.collectEases(this, el, p);
+    else
+      for (const c of el.children)
+        if (c.kind === "element" && c.name === "ease")
+          this.unavailable("animation", "markup-animation", p, c.at);
+  }
+  run(source) {
+    this.fieldIndex.clear();
+    const { doc: xml, errors } = parseXml(source);
+    this.xml = xml;
+    for (const e of errors) this.error("markup-syntax", "", e.at, VERBOSE ? e.message : "");
+    const root = xml.root;
+    if (!root) return this.result();
+    if (/<(?:import|template|apply)\b/.test(source)) {
+      if (libraryCompiler.expand) libraryCompiler.expand(xml, this.opts, this.diagnostics);
+      else if ((function uses(e) {
+        return /^(?:import|template|apply)$/.test(e.name) || e.children.some((c) => c.kind === "element" && uses(c));
+      })(root))
+        this.unavailable("libraries", "markup-libraries", "", root.at);
+      if (this.failed) return this.result();
+    }
+    if (root.name !== "anima") {
+      const known = NODES.includes(root.name) || Object.hasOwn(FORMS, root.name);
+      this.error(
+        known ? "misplaced-element" : "unknown-element",
+        "",
+        root.at,
+        VERBOSE ? "the root element must be <anima>" : "",
+        VERBOSE ? suggest(root.name, ["anima"]) : ""
+      );
+      return this.result();
+    }
+    this.collectTypes(root);
+    this.collectEases(root, "");
+    const doc = this.build(root, "");
+    componentCompiler.finish?.(doc);
+    if (!this.failed && this.opts.validate !== false) {
+      for (const d of load(doc).diagnostics) {
+        let p = d.pointer;
+        while (!this.map.has(p) && p) p = p.slice(0, p.lastIndexOf("/"));
+        const at = this.map.get(p) ?? root.at;
+        this.diagnostics.push({
+          ...d,
+          ...VERBOSE && d.code === "undeclared-feature" ? { hint: `add requires="${d.hint?.split('"')[1]}" to <anima>` } : {},
+          ...d.hint && DECLARE[d.hint] ? { hint: DECLARE[d.hint] } : {},
+          line: at.line,
+          column: at.col,
+          file: at.file ?? this.opts.file,
+          ...at.related ? { related: [location(at.related)] } : {}
+        });
+      }
+    }
+    if (this.failed) return this.result();
+    for (const { key, pointer } of this.finalEases) {
+      key.pop();
+      this.map.delete(pointer);
+    }
+    const text = formatAni(doc);
+    return { ...this.result(), doc: JSON.parse(text), text };
+  }
+  result() {
+    return { diagnostics: this.diagnostics, map: this.map };
+  }
+  unexpected(e) {
+    this.error(
+      "markup-syntax",
+      "",
+      { offset: 0, line: 1, col: 1 },
+      VERBOSE ? e instanceof Error ? e.message : "invalid markup" : ""
+    );
+    return this.result();
+  }
+}
+const DECLARE = VERBOSE ? {
+  'declare it in "inputs"': 'declare it: <bool name="\u2026"/>, <number name="\u2026"/> or <trigger name="\u2026"/>',
+  'declare it in "colors"': 'declare it: <color name="\u2026" value="#\u2026"/>',
+  'declare it in "glyphs"': 'declare it: <glyph name="\u2026" d="\u2026"/>'
+} : {};
+function compile(source, opts = {}) {
+  const compiler = new Compiler(opts);
+  try {
+    return compiler.run(source);
+  } catch (e) {
+    return compiler.unexpected(e);
+  }
+}
+export {
+  Compiler,
+  compile
+};