@protoboardai/cli 0.0.0-stage → 0.2.1

package/src/bom.ts

@@ -0,0 +1,145 @@
+/**
+ * `protoboard bom` (PB-904, PB-933): the project's bill of materials, the
+ * structured model the BOM views draw (`@protoboardai/core/bom`): what one
+ * unit needs, the offers the project holds, the offer chosen for each line,
+ * what must be bought for N units (whole packs, minimum orders), and both
+ * costs in dollars. Lines come from the design, or from a release's
+ * ordering list with `--release`. Offline: it reads what the project holds
+ * and fetches nothing.
+ */
+import { definitionTrust, formatPassive, placementPart, type Project } from "@protoboardai/core";
+import { bomLines, formatUnitUsd, formatUsd, type Bom, type BomLine } from "@protoboardai/core/bom";
+import { bomFileProblems, listReleases, projectBom as sharedBom, writeBomSettings, type CostIndex } from "@protoboardai/ext-sourcing/lib/cost.ts";
+
+/** The bill's view of a loaded project. */
+export function projectCostIndex(p: Project): CostIndex {
+  const caps = new Map<string, { capability: string; provider: string }>();
+  for (const b of p.capabilities) if (b.module && !b.problem && !caps.has(b.module)) caps.set(b.module, { capability: b.capability, provider: b.provider });
+  const byPath = new Map(p.instances.map((i) => [i.path, i]));
+  let trust: ReturnType<typeof definitionTrust> | undefined;
+  return {
+    instances: p.instances,
+    definition: (id) => p.definitions.get(id)?.def as ReturnType<CostIndex["definition"]>,
+    // a researched part's CAD config models a bought part; only the project's own designs are made
+    capability: (id) => (p.definitions.get(id)?.origin.tier === "project-specific" ? caps.get(id) : undefined),
+    placement: (path) => {
+      const inst = byPath.get(path);
+      const def = inst && p.lookup(inst.definition);
+      if (!def) return undefined;
+      const placed = placementPart(def, inst.overrides);
+      return { ...(placed.mpn ? { mpn: placed.mpn } : {}), ...(placed.value ? { value: formatPassive(placed.value) } : {}) };
+    },
+    partStatus: (id) => (trust ??= definitionTrust(p))[id]?.trust,
+  };
+}
+
+/** The bill, or why there is none. `release` takes the lines of that release's ordering list instead of the design. */
+export function projectBom(p: Project, options: { release?: string; units?: number; now?: string } = {}): Bom {
+  if (options.units !== undefined && !(Number.isInteger(options.units) && options.units > 0)) throw new Error("--units is a whole number, 1 or more");
+  const problems = bomFileProblems(p.root);
+  if (problems.length) throw new Error(problems.map((x) => `${x.file}: ${x.message}`).join("\n"));
+  let release;
+  if (options.release) {
+    const all = listReleases(p.root);
+    release = all.find((r) => r.version === options.release);
+    if (!release) throw new Error(`no release ${options.release} in release/ (releases: ${all.map((r) => r.version).join(", ") || "none"})`);
+    if (!release.hasOrderingList) throw new Error(`release ${options.release} has no ordering list (release/${options.release}/system/ordering-list.csv)`);
+  }
+  const bom = sharedBom(p.root, p.name, projectCostIndex(p), { ...(release ? { release } : {}), ...(options.units ? { units: options.units } : {}), ...(options.now ? { now: options.now } : {}) });
+  if (!bom || !bom.counts.lines) throw new Error("nothing to list: the system has no parts yet");
+  return bom;
+}
+
+/** The line a person names: its key, its definition id, or its ordering code. */
+export function findLine(bom: Bom, name: string): BomLine {
+  const lines = bomLines(bom);
+  const hit = lines.filter((l) => l.key === name);
+  const found = hit.length ? hit : lines.filter((l) => l.definition === name || (l.mpn && l.mpn.toLowerCase() === name.toLowerCase()));
+  if (found.length === 1) return found[0];
+  if (!found.length) throw new Error(`no line "${name}" in the bill of materials (lines: ${lines.map((l) => l.key).join(", ")})`);
+  throw new Error(`"${name}" names ${found.length} lines; use one of: ${found.map((l) => l.key).join(", ")}`);
+}
+
+/** Choose a line's offer by its id or its supplier's name; `auto` goes back to the best offer by the rules. Writes parts/bom.json. */
+export function chooseOffer(p: Project, lineName: string, offerName: string): { line: string; offer: string | null; supplier?: string } {
+  const bom = projectBom(p);
+  const line = findLine(bom, lineName);
+  if (line.kind !== "buy") throw new Error(`${line.key} is ${line.kind === "make" ? "made, not bought" : "included with another part"}: it has no offers`);
+  if (offerName === "auto") {
+    writeBomSettings(p.root, { offer: { line: line.key, offer: null } });
+    return { line: line.key, offer: null };
+  }
+  const byId = line.offers.filter((o) => o.id === offerName);
+  const found = byId.length ? byId : line.offers.filter((o) => o.supplier.toLowerCase() === offerName.toLowerCase());
+  if (!found.length) throw new Error(`${line.key} holds no offer "${offerName}" (offers: ${line.offers.map((o) => o.id).join(", ") || "none; fetch them with `protoboard parts offers`"})`);
+  if (found.length > 1) throw new Error(`"${offerName}" names ${found.length} offers of ${line.key}; use an id: ${found.map((o) => o.id).join(", ")}`);
+  writeBomSettings(p.root, { offer: { line: line.key, offer: found[0].id } });
+  return { line: line.key, offer: found[0].id, supplier: found[0].supplier };
+}
+
+const day = (iso?: string) => (iso ? iso.slice(0, 10) : "");
+
+/** The offers a line holds, best first, for the units the bill is priced at. */
+export function formatOffers(bom: Bom, line: BomLine): string {
+  const out = [`${line.item} (${line.key}) · ${line.quantity} per unit × ${bom.units} = ${line.needed} needed`];
+  if (!line.offers.length) out.push("  no offers held (`protoboard parts offers` fetches the library's)");
+  for (const q of line.quotes) {
+    const o = line.offers.find((x) => x.id === q.offer)!;
+    const price = q.unitPrice !== undefined ? `${formatUnitUsd(q.unitPrice)} × ${q.buy} = ${formatUsd(q.orderCost!)}` : q.problem === "no-rate" ? `no rate for ${o.currency}` : "no price";
+    const marks = [
+      q.offer === line.chosen ? (line.choice === "pinned" ? "chosen" : "used") : "",
+      q.native ? `from ${q.native.unitPrice} ${q.native.currency}` : "",
+      q.packSize > 1 ? `pack of ${q.packSize}` : "",
+      q.minOrder > 1 ? `min ${q.minOrder}` : "",
+      typeof o.stock === "number" ? `stock ${o.stock}` : "",
+      q.stale ? "stale" : "",
+      q.fit === "reel-over" ? "full reel" : "",
+      day(o.observedAt),
+    ].filter(Boolean);
+    out.push(`  ${q.offer === line.chosen ? "▸" : " "} ${o.id.padEnd(44)} ${price.padEnd(30)} ${marks.join(" · ")}`);
+  }
+  return out.join("\n");
+}
+
+/** The bill as text: one block per module, both totals last. */
+export function formatBom(t: Bom): string {
+  const src = t.source.kind === "design" ? "the design" : t.source.kind === "release" ? `release ${t.source.version} (${t.source.file})` : t.source.file;
+  const cols = (l: BomLine) => {
+    const o = l.offers.find((x) => x.id === l.chosen);
+    const q = l.quote;
+    const right =
+      l.status === "priced"
+        ? `${formatUnitUsd(q!.unitPrice!).padStart(9)} ${formatUsd(l.perUnitCost!).padStart(10)} ${String(q!.buy).padStart(6)} ${formatUsd(l.orderCost!).padStart(11)}  ${o!.supplier}${l.choice === "pinned" ? " (chosen)" : ""}`
+        : l.status === "make"
+          ? "needs a quote"
+          : l.status === "included"
+            ? "included"
+            : "unpriced";
+    return `  ${l.item.slice(0, 38).padEnd(38)} ${(l.mpn || "—").slice(0, 18).padEnd(18)} ${String(l.quantity).padStart(4)} ${right}`;
+  };
+  const notable = (l: BomLine) => (l.status === "priced" || l.status === "unpriced" ? l.notes : []);
+  const lines = [
+    `Bill of materials · ${t.project} · ${src} · ${t.units} unit${t.units === 1 ? "" : "s"} · ${t.currency}`,
+    "",
+    `  ${"Part".padEnd(38)} ${"MPN".padEnd(18)} ${"Qty".padStart(4)} ${"Unit".padStart(9)} ${"Per unit".padStart(10)} ${"Buy".padStart(6)} ${"Order".padStart(11)}  Supplier`,
+    ...t.groups.flatMap((g) => [
+      "",
+      `${g.name}${g.quantity > 1 ? ` ×${g.quantity}` : ""} (${g.lines.length} line${g.lines.length === 1 ? "" : "s"}${g.orderCost ? `, ${formatUsd(g.orderCost)}` : ""})`,
+      ...g.lines.flatMap((l) => [cols(l), ...notable(l).map((n) => `      ${n}`)]),
+    ]),
+    "",
+    t.counts.priced
+      ? `Per unit:  ${formatUsd(t.totals.perUnit)}  (the parts one unit uses)`
+      : "Per unit:  nothing priced",
+    ...(t.counts.priced
+      ? [`Order:     ${formatUsd(t.totals.order)}  for ${t.units} unit${t.units === 1 ? "" : "s"}${t.units > 1 ? ` (${formatUsd(t.totals.orderPerUnit)} each)` : ""}${t.totals.surplus > 0 ? `; ${formatUsd(t.totals.surplus)} of it buys pieces left over (packs and minimum orders)` : ""}`]
+      : []),
+    `Lines:     ${t.counts.priced} of ${t.counts.buy} bought line(s) priced, ${t.counts.unpriced} unpriced, ${t.counts.make} made (need a quote), ${t.counts.included} included${t.counts.stale ? `; ${t.counts.stale} stale price(s)` : ""}`,
+    ...(t.fx.used.length
+      ? [`Converted: ${t.counts.converted} line(s), with the ${t.fx.source}${t.fx.project ? " (parts/fx-rates.json)" : ""} of ${t.fx.date}: ${t.fx.used.map((u) => `1 ${u.currency} = ${u.rate} USD`).join(", ")}`]
+      : []),
+    ...(t.prices.newest ? [`Prices:    observed ${day(t.prices.oldest)}${day(t.prices.oldest) !== day(t.prices.newest) ? ` to ${day(t.prices.newest)}` : ""}${t.offersRetrievedAt ? `; the library's offers were fetched ${day(t.offersRetrievedAt)}` : ""}. Tax and shipping are not included.`] : []),
+    ...(t.unknownChoices.length ? [`Note:      parts/bom.json chooses offers for lines the bill no longer has: ${t.unknownChoices.join(", ")}`] : []),
+  ];
+  return lines.join("\n");
+}

package/src/dev/build-worker.ts

@@ -0,0 +1,63 @@
+/**
+ * One `protoboard dev` build, in a process of its own: load the project (every
+ * validator that can run), write the UHD bundle atomically, and print one JSON
+ * line describing the result. Next to the bundle it writes where each
+ * definition and instance is declared (`sources.json`, ./sources.ts), for
+ * the viewer's openSource. A fresh process per build means every project
+ * source is evaluated again; the dev server's own module cache never holds a
+ * stale definition.
+ *
+ *   node --import <tsx> build-worker.ts <project root> <bundle file>
+ */
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { definitionTrust, loadProject, resolveViews, stableStringify, uhdBundle, type PartTrust, type ResolvedView } from "@protoboardai/core";
+import { SOURCES_FILE, sourceIndex } from "./sources.js";
+
+export interface BuildReport {
+  ok: boolean;
+  /** Milliseconds spent loading, checking and writing. */
+  ms: number;
+  error?: string;
+  bytes?: number;
+  counts?: { error: number; warning: number; info: number };
+  /** What the dev server watches, from the project's configuration. */
+  watch?: { display: string; sources: string[]; catalog: string; scenarios?: string };
+  /** Views the project's extensions contribute (`contributes.views`), for the web viewer's tabs. */
+  views?: ResolvedView[];
+  /** Every definition's part status by id (PB-932): the viewer's shells mark the modules with it. */
+  partStatus?: Record<string, { trust: PartTrust; basis: string }>;
+}
+
+async function main() {
+  const [root, bundleFile] = process.argv.slice(2);
+  const t0 = Date.now();
+  const report = (r: Omit<BuildReport, "ms">) => process.stdout.write(JSON.stringify({ ...r, ms: Date.now() - t0 }) + "\n");
+  try {
+    const p = await loadProject(root);
+    const watch = {
+      display: p.config.display ?? ".protoboard/display.json",
+      sources: p.config.sources ?? ["src/**/*.uhd.ts"],
+      catalog: p.config.catalog ?? "parts/catalog",
+      ...(p.config.scenarios ? { scenarios: p.config.scenarios.source } : {}),
+    };
+    const data = stableStringify(await uhdBundle(p));
+    // the server may be reading either file: replace each in one step
+    const write = (file: string, content: string) => {
+      mkdirSync(dirname(file), { recursive: true });
+      const tmp = join(dirname(file), `.${basename(file)}.${process.pid}.tmp`);
+      writeFileSync(tmp, content);
+      renameSync(tmp, file);
+    };
+    write(join(dirname(bundleFile), SOURCES_FILE), JSON.stringify(sourceIndex(p)));
+    write(bundleFile, data);
+    const n = (s: string) => p.diagnostics.filter((d) => d.severity === s).length;
+    const { views } = resolveViews(p.extensions);
+    report({ ok: true, bytes: data.length, counts: { error: n("error"), warning: n("warning"), info: n("info") }, watch, ...(views.length ? { views } : {}), partStatus: definitionTrust(p) });
+  } catch (e) {
+    report({ ok: false, error: (e as Error).message.split("\n")[0] });
+    process.exitCode = 1;
+  }
+}
+
+await main();

package/src/dev/layout.ts

@@ -0,0 +1,199 @@
+/**
+ * Layout edits from the viewer → `.protoboard/display.json` (PB-815).
+ *
+ * The viewer reports what the user changed as a `ViewerLayout`: dragged node
+ * positions and link layouts (waypoints, label and harness-tab placement) per
+ * drill level. The project keeps its diagram layout as display hints:
+ * `diagram.layouts[<level>]`, a `LevelLayout` whose top-level nodes are
+ * absolute and whose nodes inside a container are relative to it. This module
+ * folds the first into the second.
+ *
+ * Two facts about the viewer (uhd-viewer 0.1.0) shape it:
+ *
+ * - Dragged positions arrive in absolute canvas coordinates for every node,
+ *   children included (its Canvas adds the parent's offset before reporting a
+ *   move). A child's relative position is its absolute position minus its
+ *   container's, where the container is placed as the viewer places it: by
+ *   its own edit, else by its hand position inside its own container.
+ * - A level with a hand layout is not laid out automatically: nodes the hand
+ *   layout does not name sit at (0, 0) of their container. So the first save
+ *   of a level that has no hand layout yet must name every node of the level.
+ *   Those positions come from the page (`LayoutSnapshot`, read from the
+ *   rendered diagram); without a snapshot that covers the edits, the level is
+ *   not written and is reported as skipped.
+ */
+
+/** As in the viewer's host contract (`@deltarobotics/uhd-viewer`, `LinkLayout`). */
+export interface LinkLayout {
+  waypoints?: [number, number][];
+  labelT?: number;
+  labelFlip?: boolean;
+  tabT?: number;
+  tabFlip?: boolean;
+}
+
+/** As in the viewer's host contract (`ViewerLayout`): both maps keyed by drill level ("" = top). */
+export interface ViewerLayout {
+  positions: Record<string, Record<string, { x: number; y: number }>>;
+  links: Record<string, Record<string, LinkLayout>>;
+}
+
+/** One level of `diagram.layouts` in display.json, as the viewer reads it. */
+export interface LevelLayout {
+  nodes: Record<string, { x?: number; y?: number; w?: number; h?: number }>;
+  ports?: Record<string, string>;
+  links?: Record<string, LinkLayout>;
+}
+
+export interface DisplayFile {
+  schema?: string;
+  diagram?: { layouts?: Record<string, LevelLayout>; [key: string]: unknown };
+  [key: string]: unknown;
+}
+
+/** What the page sees on the canvas when it sends a layout: the level on screen. */
+export interface LayoutSnapshot {
+  /** Absolute position of every node drawn, by node id. */
+  nodes: Record<string, { x: number; y: number }>;
+  /** Ids of the edges drawn (a link's edges start with its id). */
+  edges: string[];
+}
+
+export const DISPLAY_SCHEMA = "uhd.display/v0";
+
+export interface LayoutMerge {
+  display: DisplayFile;
+  /** Levels whose layout changed. */
+  levels: string[];
+  /** Levels with edits that could not be written, and why. */
+  skipped: { level: string; reason: string }[];
+}
+
+const parentOf = (id: string) => (id.includes("/") ? id.slice(0, id.lastIndexOf("/")) : undefined);
+const depth = (id: string) => id.split("/").length;
+const same = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b);
+
+/** Whether the snapshot shows the level these edits were made on. */
+function shows(snapshot: LayoutSnapshot | undefined, nodes: string[], links: string[]): boolean {
+  if (!snapshot) return false;
+  if (!nodes.every((id) => snapshot.nodes[id])) return false;
+  return links.every((id) => snapshot.edges.some((e) => e === id || e.startsWith(id)));
+}
+
+/**
+ * Folds the viewer's edits into a display file. Returns a new display (the
+ * input is not modified); `levels` is empty when nothing changed.
+ */
+export function applyViewerLayout(input: DisplayFile, layout: ViewerLayout, snapshot?: LayoutSnapshot): LayoutMerge {
+  const display: DisplayFile = structuredClone(input ?? {});
+  display.schema ??= DISPLAY_SCHEMA;
+  display.diagram ??= {};
+  display.diagram.layouts ??= {};
+  const layouts = display.diagram.layouts;
+  const levels: string[] = [];
+  const skipped: LayoutMerge["skipped"] = [];
+
+  for (const level of [...new Set([...Object.keys(layout.positions ?? {}), ...Object.keys(layout.links ?? {})])].sort()) {
+    const moved = layout.positions?.[level] ?? {};
+    const linkEdits = layout.links?.[level] ?? {};
+    if (!Object.keys(moved).length && !Object.keys(linkEdits).length) continue;
+    const before = layouts[level];
+    let hand: LevelLayout;
+    if (before) hand = structuredClone(before);
+    else {
+      // first save of an automatically laid out level: name every node it shows
+      if (!shows(snapshot, Object.keys(moved), Object.keys(linkEdits))) {
+        skipped.push({ level, reason: `level "${level}" has no saved layout yet and is not the one on screen; its edits stay in the viewer until it is saved from that level` });
+        continue;
+      }
+      hand = { nodes: {} };
+      const abs = snapshot!.nodes;
+      for (const id of Object.keys(abs).sort((a, b) => depth(a) - depth(b) || a.localeCompare(b))) {
+        const parent = parentOf(id);
+        const origin = parent && abs[parent] ? abs[parent] : { x: 0, y: 0 };
+        hand.nodes[id] = { x: abs[id].x - origin.x, y: abs[id].y - origin.y };
+      }
+    }
+
+    // absolute placement as the viewer computes it: a node's own edit, else its container's placement plus its hand offset
+    const placed = new Map<string, { x: number; y: number }>();
+    const absolute = (id: string): { x: number; y: number } => {
+      const hit = placed.get(id);
+      if (hit) return hit;
+      const parent = parentOf(id);
+      const own = moved[id];
+      let at: { x: number; y: number };
+      if (own) at = { x: own.x, y: own.y };
+      else {
+        const base = parent ? absolute(parent) : { x: 0, y: 0 };
+        at = { x: base.x + (hand.nodes[id]?.x ?? 0), y: base.y + (hand.nodes[id]?.y ?? 0) };
+      }
+      placed.set(id, at);
+      return at;
+    };
+    // containers before their children, so a child is placed against its container's new position
+    for (const id of Object.keys(moved).sort((a, b) => depth(a) - depth(b) || a.localeCompare(b))) {
+      const parent = parentOf(id);
+      const origin = parent ? absolute(parent) : { x: 0, y: 0 };
+      const at = absolute(id);
+      hand.nodes[id] = { ...hand.nodes[id], x: at.x - origin.x, y: at.y - origin.y };
+    }
+    if (Object.keys(linkEdits).length) {
+      hand.links ??= {};
+      for (const [id, edit] of Object.entries(linkEdits)) hand.links[id] = { ...hand.links[id], ...edit };
+    }
+    if (same(before, hand)) continue;
+    layouts[level] = hand;
+    levels.push(level);
+  }
+  return { display, levels, skipped };
+}
+
+const finite = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v);
+const record = (v: unknown): v is Record<string, unknown> => !!v && typeof v === "object" && !Array.isArray(v);
+
+/** The layout and snapshot from a request body, or a reason to refuse it. */
+export function parseLayoutRequest(body: unknown): { layout: ViewerLayout; snapshot?: LayoutSnapshot; client?: string } | { error: string } {
+  if (!record(body) || !record(body.layout)) return { error: "expected { layout: { positions, links } }" };
+  const { positions = {}, links = {} } = body.layout as Record<string, unknown>;
+  if (!record(positions) || !record(links)) return { error: "layout.positions and layout.links must be objects" };
+  for (const [level, nodes] of Object.entries(positions)) {
+    if (!record(nodes)) return { error: `positions["${level}"] must be an object` };
+    for (const [id, p] of Object.entries(nodes)) if (!record(p) || !finite(p.x) || !finite(p.y)) return { error: `positions["${level}"]["${id}"] needs numeric x and y` };
+  }
+  for (const [level, byLink] of Object.entries(links)) {
+    if (!record(byLink)) return { error: `links["${level}"] must be an object` };
+    for (const [id, l] of Object.entries(byLink)) {
+      if (!record(l)) return { error: `links["${level}"]["${id}"] must be an object` };
+      const unknown = Object.keys(l).filter((k) => !["waypoints", "labelT", "labelFlip", "tabT", "tabFlip"].includes(k));
+      if (unknown.length) return { error: `links["${level}"]["${id}"] has unknown keys ${unknown.join(", ")}` };
+      if (l.waypoints !== undefined && !(Array.isArray(l.waypoints) && l.waypoints.every((w) => Array.isArray(w) && w.length === 2 && w.every(finite)))) return { error: `links["${level}"]["${id}"].waypoints must be [x, y] pairs` };
+      for (const k of ["labelT", "tabT"] as const) if (l[k] !== undefined && !finite(l[k])) return { error: `links["${level}"]["${id}"].${k} must be a number` };
+      for (const k of ["labelFlip", "tabFlip"] as const) if (l[k] !== undefined && typeof l[k] !== "boolean") return { error: `links["${level}"]["${id}"].${k} must be a boolean` };
+    }
+  }
+  let snapshot: LayoutSnapshot | undefined;
+  if (body.snapshot !== undefined) {
+    const s = body.snapshot;
+    if (!record(s) || !record(s.nodes) || !Array.isArray(s.edges) || !s.edges.every((e) => typeof e === "string")) return { error: "snapshot must be { nodes, edges }" };
+    for (const [id, p] of Object.entries(s.nodes)) if (!record(p) || !finite(p.x) || !finite(p.y)) return { error: `snapshot.nodes["${id}"] needs numeric x and y` };
+    snapshot = s as unknown as LayoutSnapshot;
+  }
+  return {
+    layout: { positions: positions as ViewerLayout["positions"], links: links as ViewerLayout["links"] },
+    ...(snapshot ? { snapshot } : {}),
+    ...(typeof body.client === "string" ? { client: body.client.slice(0, 64) } : {}),
+  };
+}
+
+/**
+ * The display file's text: two-space JSON. When the file on disk escapes
+ * non-ASCII characters (`…`, as Python's json module writes it) and
+ * holds none literally, the new text escapes them too, so a layout save
+ * does not rewrite lines nobody edited.
+ */
+export function formatDisplay(display: DisplayFile, previous?: string): string {
+  const text = JSON.stringify(display, null, 2) + "\n";
+  const escaped = previous !== undefined && /\\u(?:00[89a-fA-F][0-9a-fA-F]|0[1-9a-fA-F][0-9a-fA-F]{2}|[1-9a-fA-F][0-9a-fA-F]{3})/.test(previous) && !/[^\x00-\x7f]/.test(previous);
+  return escaped ? text.replace(/[\u0080-￿]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`) : text;
+}