animl-cli 0.0.0-stage → 0.1.1

package/packages/cli/src/font/woff2.js

@@ -0,0 +1,166 @@
+import { Bytes, fault, MAX_FONT } from "./binary.js";
+import { encodeGlyph } from "./truetype.js";
+class Stream {
+  b;
+  p = 0;
+  constructor(data) {
+    this.b = new Bytes(data);
+  }
+  u8() {
+    return this.b.u8(this.p++);
+  }
+  u16() {
+    const v = this.b.u16(this.p);
+    this.p += 2;
+    return v;
+  }
+  i16() {
+    const v = this.b.i16(this.p);
+    this.p += 2;
+    return v;
+  }
+  take(n) {
+    const v = this.b.slice(this.p, n);
+    this.p += n;
+    return v;
+  }
+  uint255() {
+    const c = this.u8();
+    return c === 253 ? this.u16() : c === 255 ? this.u8() + 253 : c === 254 ? this.u8() + 506 : c;
+  }
+}
+function restoreGlyf(tables, expectedLoca) {
+  const b = new Bytes(tables.get("glyf") ?? fault("missing transformed glyf"));
+  if (b.u16(0) !== 0 || b.u16(2) > 1) fault("unsupported WOFF2 glyf version", "font-unsupported");
+  const count = b.u16(4), format = b.u16(6);
+  if (format > 1 || expectedLoca !== (count + 1) * (format ? 4 : 2))
+    fault("invalid transformed loca size");
+  let p = 36;
+  const streams = [];
+  for (let i = 0; i < 7; i++) {
+    const n = b.u32(8 + i * 4);
+    streams.push(new Stream(b.slice(p, n)));
+    p += n;
+  }
+  const [nContours, nPoints, flags, glyph, composite, boxes, instructions] = streams;
+  const bitmap = boxes.take(4 * Math.floor((count + 31) / 32)), overlap = b.u16(2) & 1 ? b.slice(p, Math.ceil(count / 8)) : void 0;
+  const locations = [], glyphs = [];
+  let offset = 0;
+  for (let id = 0; id < count; id++) {
+    locations.push(offset);
+    const nc = nContours.i16(), hasBox = !!(bitmap[id >> 3] & 128 >> (id & 7));
+    let raw;
+    if (!nc) {
+      if (hasBox) fault("empty WOFF2 glyph has a bounding box");
+      raw = Buffer.alloc(0);
+    } else if (nc > 0) {
+      const contours = [], lengths = [];
+      let total = 0;
+      for (let i = 0; i < nc; i++) {
+        const n = nPoints.uint255();
+        total += n;
+        if (!n || total > 65535) fault("invalid WOFF2 point count");
+        lengths.push(n);
+      }
+      let x = 0, y = 0;
+      for (const length2 of lengths) {
+        const contour = [];
+        for (let j = 0; j < length2; j++) {
+          const flag = flags.u8(), f = flag & 127;
+          let dx = 0, dy = 0;
+          const sign = (n, positive) => positive ? n : -n;
+          if (f < 10) dy = sign(((f & 14) << 7) + glyph.u8(), f & 1);
+          else if (f < 20) dx = sign(((f - 10 & 14) << 7) + glyph.u8(), f & 1);
+          else if (f < 84) {
+            const a = f - 20, v = glyph.u8();
+            dx = sign(1 + (a & 48) + (v >> 4), f & 1);
+            dy = sign(1 + ((a & 12) << 2) + (v & 15), f & 2);
+          } else if (f < 120) {
+            const a = f - 84;
+            dx = sign(1 + Math.floor(a / 12) * 256 + glyph.u8(), f & 1);
+            dy = sign(1 + Math.floor(a % 12 / 4) * 256 + glyph.u8(), f & 2);
+          } else if (f < 124) {
+            const a = glyph.u8(), c = glyph.u8(), d = glyph.u8();
+            dx = sign(a * 16 + (c >> 4), f & 1);
+            dy = sign((c & 15) * 256 + d, f & 2);
+          } else {
+            dx = sign(glyph.u16(), f & 1);
+            dy = sign(glyph.u16(), f & 2);
+          }
+          x += dx;
+          y += dy;
+          if (x < -32768 || x > 32767 || y < -32768 || y > 32767)
+            fault("WOFF2 coordinate overflow");
+          contour.push({ x, y, on: !(flag & 128) });
+        }
+        contours.push(contour);
+      }
+      const length = glyph.uint255();
+      raw = encodeGlyph(
+        contours,
+        instructions.take(length),
+        !!(overlap?.[id >> 3] && overlap[id >> 3] & 128 >> (id & 7))
+      );
+      if (hasBox) boxes.take(8).copy(raw, 2);
+    } else if (nc === -1) {
+      if (!hasBox) fault("WOFF2 composite is missing bbox");
+      let more = true, hasInstructions = false;
+      const parts = [];
+      while (more) {
+        const f = composite.u16(), n = 2 + (f & 1 ? 4 : 2) + (f & 8 ? 2 : f & 64 ? 4 : f & 128 ? 8 : 0), part = Buffer.alloc(2 + n);
+        part.writeUInt16BE(f);
+        composite.take(n).copy(part, 2);
+        parts.push(part);
+        more = !!(f & 32);
+        hasInstructions ||= !!(f & 256);
+      }
+      const head2 = Buffer.alloc(10);
+      head2.writeInt16BE(-1);
+      boxes.take(8).copy(head2, 2);
+      parts.unshift(head2);
+      if (hasInstructions) {
+        const n = glyph.uint255(), len = Buffer.alloc(2);
+        len.writeUInt16BE(n);
+        parts.push(len, instructions.take(n));
+      }
+      raw = Buffer.concat(parts);
+    } else return fault("invalid WOFF2 contour count");
+    if (raw.length & 1) raw = Buffer.concat([raw, Buffer.alloc(1)]);
+    glyphs.push(raw);
+    offset += raw.length;
+    if (offset > MAX_FONT) fault("reconstructed WOFF2 exceeds size limit", "font-limit");
+    if (!format && offset > 131070) fault("reconstructed WOFF2 short loca overflows");
+  }
+  locations.push(offset);
+  for (const s of streams)
+    if (s.p !== s.b.data.length) fault("WOFF2 transformed stream length mismatch");
+  const loca = Buffer.alloc(expectedLoca);
+  locations.forEach(
+    (v, i) => format ? loca.writeUInt32BE(v, i * 4) : loca.writeUInt16BE(v / 2, i * 2)
+  );
+  tables.set("glyf", Buffer.concat(glyphs));
+  tables.set("loca", loca);
+  const head = Buffer.from(tables.get("head") ?? fault("missing head"));
+  head.writeInt16BE(format, 50);
+  tables.set("head", head);
+}
+function restoreHmtx(tables) {
+  const b = new Stream(tables.get("hmtx") ?? fault("missing hmtx")), flags = b.u8();
+  if (flags < 1 || flags > 3) fault("invalid WOFF2 hmtx flags");
+  const head = new Bytes(tables.get("head") ?? fault("missing head")), maxp = new Bytes(tables.get("maxp") ?? fault("missing maxp")), hhea = new Bytes(tables.get("hhea") ?? fault("missing hhea")), loca = new Bytes(tables.get("loca") ?? fault("missing loca")), glyf = new Bytes(tables.get("glyf") ?? fault("missing glyf"));
+  const count = maxp.u16(4), n = hhea.u16(34);
+  if (!n || n > count) fault("invalid WOFF2 metric count");
+  const out = Buffer.alloc(n * 4 + (count - n) * 2), long = head.i16(50), offset = (i) => long ? loca.u32(i * 4) : loca.u16(i * 2) * 2;
+  for (let i = 0; i < n; i++) out.writeUInt16BE(b.u16(), i * 4);
+  for (let i = 0; i < count; i++) {
+    const omitted = i < n ? flags & 1 : flags & 2;
+    const value = omitted ? offset(i) === offset(i + 1) ? 0 : glyf.i16(offset(i) + 2) : b.i16();
+    out.writeInt16BE(value, i < n ? i * 4 + 2 : n * 4 + (i - n) * 2);
+  }
+  if (b.p !== b.b.data.length) fault("WOFF2 hmtx length mismatch");
+  tables.set("hmtx", out);
+}
+export {
+  restoreGlyf,
+  restoreHmtx
+};

package/packages/cli/src/glyphs.d.ts

@@ -0,0 +1,5 @@
+export declare function inspectGlyph(d: string): {
+    index: number;
+    bbox: number[];
+    likelyHoleOf: number[];
+}[];

package/packages/cli/src/glyphs.js

@@ -0,0 +1,59 @@
+import { parsePath } from "animl";
+function bounds({ segs }) {
+  const box = [Infinity, Infinity, -Infinity, -Infinity];
+  const point = (x2, y2) => {
+    box[0] = Math.min(box[0], x2);
+    box[1] = Math.min(box[1], y2);
+    box[2] = Math.max(box[2], x2);
+    box[3] = Math.max(box[3], y2);
+  };
+  let x = 0, y = 0, sx = 0, sy = 0;
+  for (let i = 0; i < segs.length; ) {
+    const op = segs[i++];
+    if (op === 3) {
+      x = sx;
+      y = sy;
+      continue;
+    }
+    if (op !== 2) {
+      x = segs[i++];
+      y = segs[i++];
+      if (op === 0) {
+        sx = x;
+        sy = y;
+      }
+      point(x, y);
+      continue;
+    }
+    const [x1, y1, x2, y2, ex, ey] = segs.slice(i, i += 6);
+    const roots = (a, b, c, d) => {
+      const A = -a + 3 * b - 3 * c + d, B = 2 * (a - 2 * b + c), C = b - a;
+      if (Math.abs(A) < 1e-12) return Math.abs(B) < 1e-12 ? [] : [-C / B];
+      const disc = B * B - 4 * A * C;
+      if (disc < 0) return [];
+      const q = -(B + (B < 0 ? -1 : 1) * Math.sqrt(disc)) / 2;
+      return q ? [q / A, C / q] : [0];
+    };
+    const at = (a, b, c, d, t) => (1 - t) ** 3 * a + 3 * (1 - t) ** 2 * t * b + 3 * (1 - t) * t * t * c + t ** 3 * d;
+    for (const t of [...roots(x, x1, x2, ex), ...roots(y, y1, y2, ey)])
+      if (t > 0 && t < 1) point(at(x, x1, x2, ex, t), at(y, y1, y2, ey, t));
+    point(ex, ey);
+    x = ex;
+    y = ey;
+  }
+  return box;
+}
+function inspectGlyph(d) {
+  const boxes = parsePath(d).map((s) => bounds(s).map((v) => Math.round(v * 1e3) / 1e3 || 0));
+  return boxes.map((bbox, index) => ({
+    index,
+    bbox,
+    // Containment alone cannot prove a hole (winding and intersecting outlines matter).
+    likelyHoleOf: boxes.flatMap(
+      (outer, j) => j !== index && outer[0] <= bbox[0] && outer[1] <= bbox[1] && outer[2] >= bbox[2] && outer[3] >= bbox[3] && outer.some((v, k) => v !== bbox[k]) ? [j] : []
+    )
+  }));
+}
+export {
+  inspectGlyph
+};

package/packages/cli/src/help.d.ts

@@ -0,0 +1,5 @@
+import { type Command } from './commands.js';
+export declare function commandByName(name: string): Command | undefined;
+export declare function overview(all?: boolean, width?: number): string;
+export declare function commandHelp(command: Command, width?: number): string;
+export declare function helpJSON(): string;

package/packages/cli/src/help.js

@@ -0,0 +1,149 @@
+import { COMMANDS, GLOBAL, GROUPS } from "./commands.js";
+function words(text) {
+  return text.trim().split(/\s+/).filter(Boolean);
+}
+function wrap(text, width, first = "", continuation = first) {
+  const parts = words(text);
+  if (!parts.length) return first.trimEnd();
+  const lines = [];
+  let prefix = first;
+  let line = prefix;
+  for (const part of parts) {
+    const separator = line === prefix ? "" : " ";
+    if (line.length + separator.length + part.length > width && line !== prefix) {
+      lines.push(line);
+      prefix = continuation;
+      line = prefix + part;
+    } else line += separator + part;
+  }
+  lines.push(line);
+  return lines.join("\n");
+}
+function optionLabel(option) {
+  const long = `--${option.name}${option.value ? ` <${option.value}>` : ""}`;
+  return option.short ? `-${option.short}, ${long}` : long;
+}
+function tableRows(rows, width, indent = "  ") {
+  const labelWidth = Math.min(42, Math.max(0, ...rows.map(({ label }) => label.length)) + 2);
+  return rows.map(({ label, text }) => {
+    if (indent.length + label.length + 2 > Math.max(32, width * 0.58))
+      return `${wrap(label, width, indent, indent + "  ")}
+${wrap(
+        text,
+        width,
+        indent + "    ",
+        indent + "    "
+      )}`;
+    const left = indent + label.padEnd(Math.max(labelWidth, label.length + 2));
+    return wrap(text, width, left, " ".repeat(left.length));
+  }).join("\n");
+}
+function commandByName(name) {
+  return COMMANDS.find((command) => command.name === name || command.aliases?.includes(name));
+}
+function overview(all = false, width = process.stdout.columns ?? 100) {
+  const lines = [
+    "anima \u2014 check, see, and build .animl and .ani animations",
+    "",
+    "Usage:",
+    "  anima <command> [options]"
+  ];
+  for (const [group, title] of Object.entries(GROUPS)) {
+    const commands = COMMANDS.filter(
+      (command) => command.group === group && (all || !command.hidden)
+    );
+    if (!commands.length) continue;
+    lines.push(
+      "",
+      title,
+      tableRows(
+        commands.map((command) => ({
+          label: `anima ${command.usage[0]}`,
+          text: command.summary
+        })),
+        width
+      )
+    );
+  }
+  lines.push(
+    "",
+    wrap(
+      "Every command accepts --format <text|json> and -h/--help. Exit codes: 0 ok, 1 diagnostics or a failed check, 2 usage.",
+      width
+    ),
+    "",
+    "  anima features                 what Anima can do",
+    "  anima search <words>           find a capability",
+    "  anima docs authoring the-loop  follow the authoring loop"
+  );
+  return lines.join("\n");
+}
+function commandHelp(command, width = process.stdout.columns ?? 100) {
+  const lines = [
+    wrap(`anima ${command.name} \u2014 ${command.summary}`, width),
+    "",
+    "Usage:",
+    ...command.usage.map((usage) => wrap(`anima ${usage}`, width, "  ", "    "))
+  ];
+  if (command.subcommands?.length)
+    lines.push(
+      "",
+      "Subcommands:",
+      tableRows(
+        command.subcommands.map((subcommand) => ({
+          label: subcommand.name,
+          text: subcommand.summary
+        })),
+        width
+      )
+    );
+  const options = [...command.options, ...GLOBAL];
+  if (options.length)
+    lines.push(
+      "",
+      "Options:",
+      tableRows(
+        options.map((option) => ({
+          label: optionLabel(option),
+          text: `${option.summary}${option.default === void 0 ? "" : ` (default: ${option.default})`}`
+        })),
+        width
+      )
+    );
+  if (command.examples.length)
+    lines.push(
+      "",
+      "Examples:",
+      ...command.examples.flatMap((example) => [
+        wrap(`anima ${example.run}`, width, "  ", "    "),
+        wrap(example.note, width, "    ", "    ")
+      ])
+    );
+  if (command.see?.length)
+    lines.push(
+      "",
+      "See also:",
+      wrap(command.see.map((item) => `anima ${item}`).join(", "), width, "  ", "  ")
+    );
+  return lines.join("\n");
+}
+function helpJSON() {
+  return JSON.stringify(
+    {
+      groups: GROUPS,
+      global: GLOBAL,
+      commands: COMMANDS.map((command) => ({
+        ...command,
+        ...command.topics ? { topics: command.topics() } : {}
+      }))
+    },
+    null,
+    2
+  );
+}
+export {
+  commandByName,
+  commandHelp,
+  helpJSON,
+  overview
+};

package/packages/cli/src/html.d.ts

@@ -0,0 +1,5 @@
+import { type MarkupDiagnostic } from 'animl/markup';
+export declare function buildHTML(source: string, file: string, transform?: (doc: import('./build-assets.js').AssetDocument, map: import('animl/markup').CompileResult['map']) => void): {
+    text?: string;
+    diagnostics: MarkupDiagnostic[];
+};

package/packages/cli/src/html.js

@@ -0,0 +1,119 @@
+import { readFileSync } from "node:fs";
+import { formatAni } from "animl";
+import { compile } from "animl/markup";
+import { lineCol } from "./locate.js";
+function buildHTML(source, file, transform) {
+  const diagnostics = [];
+  const edits = [];
+  let icons = 0;
+  let i = 0;
+  while (i < source.length) {
+    const start = source.indexOf("<", i);
+    if (start < 0) break;
+    if (source.startsWith("<!--", start)) {
+      const end2 = source.indexOf("-->", start + 4);
+      i = end2 < 0 ? source.length : end2 + 3;
+      continue;
+    }
+    if (!/^<\/?[a-z!]/i.test(source.slice(start, start + 3))) {
+      i = start + 1;
+      continue;
+    }
+    let end = start + 1;
+    let quote = "";
+    for (; end < source.length; end++) {
+      const c = source[end];
+      if (quote) {
+        if (c === quote) quote = "";
+      } else if (c === '"' || c === "'") quote = c;
+      else if (c === ">") break;
+    }
+    i = end + 1;
+    const tag = source.slice(start, i);
+    const name = /^<\s*(\/?)\s*([a-z][\w:-]*)\b/i.exec(tag);
+    if (!name) continue;
+    const closing = !!name[1];
+    const kind = name[2].toLowerCase();
+    if (kind === "anima-icon") icons = Math.max(0, icons + (closing ? -1 : 1));
+    if (kind === "plaintext" && !closing) break;
+    if (closing || !["script", "style", "textarea", "title", "xmp", "iframe", "noembed", "noframes"].includes(
+      kind
+    ))
+      continue;
+    const close = new RegExp(`</${kind}\\s*>`, "ig");
+    close.lastIndex = i;
+    const match = close.exec(source);
+    const bodyEnd = match?.index ?? source.length;
+    const bodyStart = i;
+    i = match ? close.lastIndex : source.length;
+    if (kind !== "script") continue;
+    const attrs = /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+    attrs.lastIndex = name[0].length;
+    let type;
+    for (let a = attrs.exec(tag); a; a = attrs.exec(tag)) {
+      if (a[1].toLowerCase() !== "type" || type) continue;
+      const value = a[2] ?? a[3] ?? a[4] ?? "";
+      const eq = a[0].indexOf("=");
+      const prefix = eq < 0 ? a[0].length : eq + 1 + (a[0].slice(eq + 1).match(/^\s*/)?.[0].length ?? 0);
+      const offset = a.index + prefix + (a[2] !== void 0 || a[3] !== void 0 ? 1 : 0);
+      type = { value, start: start + offset, end: start + offset + value.length };
+    }
+    const named = { plus: "+", sol: "/", period: ".", amp: "&" };
+    const decoded = type?.value.replace(
+      /&(?:#(\d+);?|#[xX]([\da-fA-F]+);?|(plus|sol|period|amp);)/g,
+      (_, d, x, n) => n ? named[n] : String.fromCodePoint(Math.min(1114111, parseInt(d ?? x, d ? 10 : 16)))
+    );
+    if (!type || decoded?.toLowerCase() !== "application/vnd.anima+xml") continue;
+    if (!icons) {
+      const [line2, column2] = lineCol(source, start);
+      diagnostics.push({
+        file,
+        line: line2,
+        column: column2,
+        code: "markup-outside-icon",
+        severity: "warning",
+        pointer: "",
+        message: "AniML script outside <anima-icon> was left unchanged",
+        hint: "wrap the script in <anima-icon> to compile it"
+      });
+      continue;
+    }
+    const result = compile(source.slice(bodyStart, bodyEnd), {
+      file,
+      resolve: (path) => readFileSync(path, "utf8")
+    });
+    const [line, column] = lineCol(source, bodyStart);
+    diagnostics.push(
+      ...result.diagnostics.map((d) => ({
+        ...d,
+        ...d.related ? {
+          related: d.related.map(
+            (r) => r.file === file ? {
+              ...r,
+              line: line + r.line - 1,
+              column: r.column + (r.line === 1 ? column - 1 : 0)
+            } : r
+          )
+        } : {},
+        line: d.file === file ? line + (d.line ?? 1) - 1 : d.line,
+        column: d.file === file ? (d.column ?? 1) + ((d.line ?? 1) === 1 ? column - 1 : 0) : d.column
+      }))
+    );
+    if (result.text !== void 0) {
+      if (transform && result.doc) {
+        transform(result.doc, result.map);
+        result.text = formatAni(result.doc);
+      }
+      edits.push({ start: type.start, end: type.end, text: "application/vnd.anima+json" });
+      edits.push({ start: bodyStart, end: bodyEnd, text: result.text.replace(/</g, "\\u003c") });
+    }
+  }
+  if (diagnostics.some((d) => d.severity === "error")) return { diagnostics };
+  let text = source;
+  for (const edit of edits.reverse())
+    text = text.slice(0, edit.start) + edit.text + text.slice(edit.end);
+  return { text, diagnostics };
+}
+export {
+  buildHTML
+};

package/packages/cli/src/import-lottie.d.ts

@@ -0,0 +1,2 @@
+import type { Imported } from './import-svg.js';
+export declare function importLottie(source: string, name: string): Imported;