@litfamily/litclaude 1.0.10 → 1.0.13

package/plugins/litclaude/skills/lit-diagram-drawer/scripts/excalidraw-extract.mjs

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+// Bounded stdlib-only Excalidraw extraction; labels are inert, never executed.
+import { closeSync, openSync, readSync } from "node:fs";
+import { createHash } from "node:crypto";
+import path from "node:path";
+
+const MAX_INPUT = 16 * 1024 * 1024;
+const MAX_ELEMENTS = 10_000;
+const MAX_NODES = 2_000;
+const MAX_RELATIONSHIPS = 5_000;
+const MAX_DEPTH = 64;
+const URL_RE = /\b(?:https?|ftp|file|javascript|data):[^\s<>"']+/gi;
+const EXEC_RE = /<\s*(?:script|iframe|object|embed)\b|\bon[a-z]+\s*=/is;
+const ID_RE = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+const NODE_SHAPES = { rectangle: "rectangle", ellipse: "ellipse", diamond: "diamond", image: "image", embeddable: "embed", iframe: "embed" };
+const EDGE_TYPES = new Set(["arrow", "line"]);
+const CONTAINER_TYPES = new Set(["frame", "magicframe"]);
+
+class ImportFailure extends Error {}
+
+function reject(message) {
+  throw new ImportFailure(message);
+}
+
+function sha256Hex(buffer) {
+  return createHash("sha256").update(buffer).digest("hex");
+}
+
+function readBounded(filePath, maxBytes) {
+  let fd;
+  try {
+    fd = openSync(filePath, "r");
+  } catch (error) {
+    reject(`cannot read input: ${error.code === "ENOENT" ? "No such file or directory" : (error.message || "I/O error")}`);
+  }
+  try {
+    const cap = maxBytes + 1;
+    const buffer = Buffer.alloc(cap);
+    let total = 0;
+    while (total < cap) {
+      const bytesRead = readSync(fd, buffer, total, cap - total, null);
+      if (bytesRead === 0) break;
+      total += bytesRead;
+    }
+    return buffer.subarray(0, total);
+  } catch (error) {
+    reject(`cannot read input: ${error.message || "I/O error"}`);
+    return undefined;
+  } finally {
+    closeSync(fd);
+  }
+}
+
+function safeId(sourceId, used) {
+  if (!sourceId) reject("scene contains an element without an id");
+  const candidate = ID_RE.test(sourceId) ? sourceId : `n-${sha256Hex(Buffer.from(sourceId, "utf8")).slice(0, 16)}`;
+  if (used.has(candidate)) reject("scene contains duplicate or colliding element ids");
+  used.add(candidate);
+  return candidate;
+}
+
+function cleanLabel(raw) {
+  if (EXEC_RE.test(raw)) reject("executable markup or event attributes in labels are unsupported");
+  const urls = (raw.match(URL_RE) || []).length;
+  let text = raw.replace(URL_RE, "").replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+  text = [...text].filter((ch) => ch === "\n" || ch === "\t" || ch.codePointAt(0) >= 32).join("");
+  const lines = text.split(/\r\n|\r|\n/).map((line) => line.replace(/[ \t]+/g, " ").trim());
+  return [lines.filter((line) => line).join("\n").slice(0, 2_000), urls];
+}
+
+function checkJsonDepth(text) {
+  let depth = 0;
+  let quoted = false;
+  let escaped = false;
+  for (const char of text) {
+    if (quoted) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') quoted = false;
+    } else if (char === '"') {
+      quoted = true;
+    } else if (char === "[" || char === "{") {
+      depth += 1;
+    }
+    if (depth > MAX_DEPTH) {
+      reject("scene nesting exceeds the depth limit (64)");
+    } else if (char === "]" || char === "}") {
+      depth -= 1;
+    }
+  }
+}
+
+function finiteGeometry(element) {
+  for (const key of ["x", "y", "width", "height"]) {
+    const value = element[key];
+    if (value === undefined || value === null) continue;
+    if (typeof value !== "number") reject(`element geometry field ${key} must be numeric`);
+    if (!Number.isFinite(value) || Math.abs(value) > 10_000_000) reject(`element geometry field ${key} is outside the supported range`);
+  }
+}
+
+function computeTitle(filePath) {
+  const base = path.basename(filePath);
+  const stripped = base.replace(/\.excalidraw\.json$/i, "").replace(/\.excalidraw$/i, "");
+  return stripped || "Imported diagram";
+}
+
+function extract(filePath) {
+  const suffix = path.basename(filePath).toLowerCase();
+  if (!(suffix.endsWith(".excalidraw") || suffix.endsWith(".excalidraw.json"))) {
+    reject("unsupported form; provide a saved .excalidraw scene");
+  }
+  const data = readBounded(filePath, MAX_INPUT);
+  if (data.length > MAX_INPUT) reject("input exceeds the 16 MiB limit");
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(data);
+  } catch {
+    reject("scene is not valid UTF-8 JSON");
+  }
+  checkJsonDepth(text);
+  let document;
+  try {
+    document = JSON.parse(text);
+  } catch {
+    reject("scene is malformed JSON");
+  }
+  if (typeof document !== "object" || document === null || Array.isArray(document) || document.type !== "excalidraw") {
+    reject("input is not an Excalidraw scene");
+  }
+  const elements = document.elements;
+  if (!Array.isArray(elements)) reject("scene has no elements array");
+  if (elements.length > MAX_ELEMENTS) reject("element limit exceeded (max 10,000)");
+
+  const live = [];
+  const used = new Set();
+  const idMap = new Map();
+  const discarded = {
+    styles: 0, links: 0, urls: 0, scripts: 0,
+    assets: 0, unsupportedElements: 0, deletedElements: 0,
+    freehandStrokes: 0, danglingRelationships: 0,
+  };
+  for (const item of elements) {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) reject("scene element must be an object");
+    const sourceId = item.id;
+    const elementType = item.type;
+    if (typeof sourceId !== "string" || typeof elementType !== "string") reject("scene elements require string id and type fields");
+    if (idMap.has(sourceId)) reject("scene contains duplicate element ids");
+    idMap.set(sourceId, safeId(sourceId, used));
+    finiteGeometry(item);
+    if (item.isDeleted === true) {
+      discarded.deletedElements += 1;
+      continue;
+    }
+    live.push(item);
+  }
+  const frameIds = new Set(live.filter((el) => CONTAINER_TYPES.has(el.type) && typeof el.id === "string").map((el) => el.id));
+
+  const labels = new Map();
+  for (const element of live) {
+    if (element.type !== "text") continue;
+    const container = element.containerId;
+    const rawText = Object.prototype.hasOwnProperty.call(element, "text") ? element.text : "";
+    if (typeof rawText !== "string") reject("text element content must be a string");
+    const [labelText, count] = cleanLabel(rawText);
+    discarded.urls += count;
+    if (typeof container === "string" && idMap.has(container) && labelText) {
+      if (!labels.has(container)) labels.set(container, []);
+      labels.get(container).push(labelText);
+    }
+  }
+
+  const nodes = [];
+  const nodeSourceIds = new Set();
+  for (const element of live) {
+    const sourceId = element.id;
+    const elementType = element.type;
+    if (typeof sourceId !== "string" || typeof elementType !== "string") reject("scene element id and type must be strings");
+    if (EDGE_TYPES.has(elementType) || (elementType === "text" && typeof element.containerId === "string")) continue;
+    if (elementType === "selection" || elementType === "laser") continue;
+    if (elementType === "freedraw") {
+      discarded.freehandStrokes += 1;
+      continue;
+    }
+    let shape;
+    let kind;
+    let rawLabel;
+    if (CONTAINER_TYPES.has(elementType)) {
+      shape = "container";
+      kind = "container";
+      rawLabel = typeof element.name === "string" ? element.name : "";
+    } else if (elementType === "text") {
+      shape = "text";
+      kind = "annotation";
+      rawLabel = typeof element.text === "string" ? element.text : "";
+    } else if (elementType in NODE_SHAPES) {
+      shape = NODE_SHAPES[elementType];
+      kind = "component";
+      rawLabel = "";
+      if (["image", "embeddable", "iframe"].includes(elementType)) discarded.assets += 1;
+    } else {
+      discarded.unsupportedElements += 1;
+      continue;
+    }
+    const [cleaned, count] = cleanLabel(rawLabel);
+    discarded.urls += count;
+    let finalLabel = cleaned;
+    const bound = labels.get(sourceId) || [];
+    if (bound.length) finalLabel = bound.join("\n").slice(0, 2_000);
+    const link = element.link;
+    if (typeof link === "string" && link) {
+      discarded.links += 1;
+      discarded.urls += (link.match(URL_RE) || []).length > 0 ? 1 : 0;
+    }
+    if (nodes.length >= MAX_NODES) reject("node limit exceeded (max 2,000)");
+    const node = { id: idMap.get(sourceId), label: finalLabel, kind, shape };
+    const parent = element.frameId;
+    if (typeof parent === "string" && frameIds.has(parent)) node.parentId = idMap.get(parent);
+    nodes.push(node);
+    nodeSourceIds.add(sourceId);
+  }
+
+  const relationships = [];
+  for (const element of live) {
+    if (!EDGE_TYPES.has(element.type)) continue;
+    const sourceId = element.id;
+    if (typeof sourceId !== "string") continue;
+    const start = element.startBinding;
+    const end = element.endBinding;
+    const startId = start && typeof start === "object" && !Array.isArray(start) ? start.elementId : undefined;
+    const endId = end && typeof end === "object" && !Array.isArray(end) ? end.elementId : undefined;
+    if (typeof startId !== "string" || typeof endId !== "string" || !nodeSourceIds.has(startId) || !nodeSourceIds.has(endId)) {
+      discarded.danglingRelationships += 1;
+      continue;
+    }
+    const rawLabel = (labels.get(sourceId) || []).join("\n");
+    const [labelText, count] = cleanLabel(rawLabel);
+    discarded.urls += count;
+    const startHead = element.startArrowhead;
+    const endHead = element.endArrowhead;
+    const hasStart = typeof startHead === "string" && startHead !== "" && startHead !== "none";
+    const hasEnd = typeof endHead === "string" && endHead !== "" && endHead !== "none";
+    const direction = hasStart && hasEnd ? "both" : hasStart ? "reverse" : (hasEnd || element.type === "arrow") ? "forward" : "none";
+    relationships.push({
+      from: idMap.get(startId), to: idMap.get(endId), label: labelText,
+      kind: element.type === "arrow" ? "flow" : "association", direction,
+    });
+  }
+  if (relationships.length > MAX_RELATIONSHIPS) reject("relationship limit exceeded (max 5,000)");
+
+  const groups = [];
+  for (const frameId of [...frameIds].sort()) {
+    const members = live
+      .filter((el) => el.frameId === frameId && typeof el.id === "string" && nodeSourceIds.has(el.id))
+      .map((el) => el.id);
+    if (members.length) {
+      const frameNode = nodes.find((node) => node.id === idMap.get(frameId));
+      const labelText = frameNode ? String(frameNode.label) : "Frame";
+      groups.push({ id: idMap.get(frameId), label: labelText, nodeIds: members.map((m) => idMap.get(m)) });
+    }
+  }
+  const sourceGroups = new Map();
+  for (const element of live) {
+    const elementId = element.id;
+    const groupIdsField = element.groupIds;
+    if (typeof elementId === "string" && nodeSourceIds.has(elementId) && Array.isArray(groupIdsField)) {
+      for (const groupId of groupIdsField.slice(0, 64)) {
+        if (typeof groupId === "string") {
+          if (!sourceGroups.has(groupId) && sourceGroups.size >= MAX_NODES) reject("group limit exceeded (max 2,000)");
+          if (!sourceGroups.has(groupId)) sourceGroups.set(groupId, []);
+          sourceGroups.get(groupId).push(elementId);
+        }
+      }
+    }
+  }
+  for (const [groupId, members] of sourceGroups) {
+    const groupSafeId = `g-${sha256Hex(Buffer.from(groupId, "utf8")).slice(0, 16)}`;
+    if (used.has(groupSafeId)) reject("group id collides with an element id");
+    used.add(groupSafeId);
+    groups.push({ id: groupSafeId, label: "Group", nodeIds: members.map((m) => idMap.get(m)) });
+  }
+
+  if (!nodes.length) reject("scene contains no supported diagram elements");
+  discarded.styles = live.filter((el) => ["backgroundColor", "strokeColor", "strokeStyle", "roughness"].some((key) => key in el)).length;
+  const files = document.files;
+  if (files && typeof files === "object" && !Array.isArray(files)) discarded.assets += Object.keys(files).length;
+  const suggested = relationships.length ? "flowchart" : "architecture";
+
+  return {
+    schemaVersion: 1,
+    sourceFormat: "excalidraw",
+    sourceDigest: sha256Hex(data),
+    title: computeTitle(filePath),
+    suggestedType: suggested,
+    nodes, relationships, groups,
+    discarded,
+    warnings: ["Source coordinates and styling are omitted; label text is inert data."],
+  };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const file = args.find((arg) => !arg.startsWith("--"));
+  if (!file) {
+    process.stderr.write("Usage: node scripts/excalidraw-extract.mjs <file>\n");
+    return 2;
+  }
+  try {
+    const result = extract(file);
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return 0;
+  } catch (error) {
+    const message = error instanceof ImportFailure ? error.message : (error && error.message ? error.message : String(error));
+    process.stderr.write(`excalidraw_extract: ${message}\n`);
+    return 2;
+  }
+}
+
+process.exitCode = main();

package/plugins/litclaude/skills/lit-diagram-drawer/scripts/export.mjs

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { buildBlockRegistry } from './block-registry.mjs';
+import { decodeXmlCharacterReferences, officeCssUrlsAreSafe, officeHrefRefsAreSafe } from './office-safety.mjs';
+import { probeRenderer } from './renderer.mjs';
+
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const args=process.argv.slice(2);
+const value=(flag,fallback)=>{const i=args.indexOf(flag);return i>=0?args[i+1]:fallback;};
+const input=value('--input',args.find((x)=>!x.startsWith('--')));
+const output=path.resolve(value('--out',path.join(process.cwd(),'diagram-exports')));
+const all=args.includes('--all-scales');
+const office=args.includes('--office-safe');
+const registry=args.includes('--registry');
+const allowFontFallback=args.includes('--allow-font-fallback');
+const selected=Number(value('--scale','3'));
+if(!input||(!all&&![1,2,3].includes(selected))){console.error('Usage: node scripts/export.mjs --input <file.html|file.svg> [--out DIR] [--scale 1|2|3|--all-scales] [--office-safe] [--registry] [--allow-font-fallback]');process.exit(2);}
+if(path.basename(input)==='index.html'){console.error('EXPORT_SOURCE_REJECTED gallery pages are not diagram sources');process.exit(2);}
+const resolved=path.resolve(input);
+if(!fs.existsSync(resolved)){console.error('INPUT_MISSING '+resolved);process.exit(2);}
+const renderer=probeRenderer();
+if(!renderer.ok){console.error((renderer.agentBrowser.ok?'CHROME_REQUIRED ':'RENDERER_REQUIRED ')+(renderer.agentBrowser.ok?renderer.chrome.detail:renderer.agentBrowser.detail)+'\nThis exporter never installs software. Run these steps yourself, then retry:\n  '+renderer.setup.join('\n  '));process.exit(2);}
+let source=fs.readFileSync(resolved,'utf8');
+const svgMatch=source.match(/<svg\b[^>]*>[\s\S]*?<\/svg>/i);
+if(!svgMatch){console.error('SVG_MISSING '+resolved);process.exit(2);}
+const svg=svgMatch[0];
+let registryData=null;
+if(registry){try{registryData=buildBlockRegistry(svg,resolved);}catch(e){console.error('REGISTRY_FAILED '+e.message);process.exit(2);}}
+const view=svg.match(/\bviewBox\s*=\s*["']([^"']+)["']/i)?.[1]?.trim().split(/[\s,]+/).map(Number);
+if(!view||view.length!==4||view.some((x)=>!Number.isFinite(x))){console.error('VIEWBOX_REQUIRED '+resolved);process.exit(2);}
+let officeSvg=null;
+if(office){
+  const font=path.join(root,'assets/fonts/PretendardVariable.woff2');
+  if(!fs.existsSync(font)){console.error('FONT_MISSING '+font);process.exit(2);}
+  const normalizedOfficeSource=decodeXmlCharacterReferences(svg);
+  if(normalizedOfficeSource===null){console.error('OFFICE_UNSAFE_ACTIVE_OR_EXTERNAL_CONTENT');process.exit(2);}
+  officeSvg=svg.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi,'');
+  if(/<foreignObject\b|\bon[a-z]+\s*=|<script\b/i.test(normalizedOfficeSource)||!officeHrefRefsAreSafe(normalizedOfficeSource)){console.error('OFFICE_UNSAFE_ACTIVE_OR_EXTERNAL_CONTENT');process.exit(2);}
+  if(/\bvar\s*\(|@import/i.test(normalizedOfficeSource)||!officeCssUrlsAreSafe(normalizedOfficeSource)){console.error('OFFICE_UNSUPPORTED_CSS_URL_OR_VARIABLE');process.exit(2);}
+  officeSvg=officeSvg.replace(/<filter\b[^>]*>[\s\S]*?<\/filter>/gi,'');
+  officeSvg=officeSvg.replace(/\s+(?:filter|mask)\s*=\s*(["'])url\(#.*?\)\1/gi,'');
+  officeSvg=officeSvg.replace(/<(rect|circle|ellipse|line|path|polygon|polyline|text)\b([^>]*)>/gi,(tag,name,attributes)=>{
+    let extra='';
+    const converted=attributes.replace(/(\b(?:fill|stroke)\s*=\s*)(["'])(.*?)\2/gi,(whole,prefix,quote,value)=>{
+      if(value.toLowerCase()==='transparent')return prefix+quote+'none'+quote;
+      const rgba=value.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)(?:\s*,\s*([\d.]+))?\s*\)$/i);
+      if(!rgba)return whole;
+      const channels=rgba.slice(1,4).map((n)=>Math.max(0,Math.min(255,Number(n))).toString(16).padStart(2,'0'));
+      const alpha=rgba[4]===undefined?1:Math.max(0,Math.min(1,Number(rgba[4])));
+      if(alpha<1)extra+=' '+prefix.trim().split('=')[0]+'-opacity="'+alpha+'"';
+      return prefix+quote+'#'+channels.join('')+quote;
+    });
+    return '<'+name+converted+extra+'>';
+  });
+  const rootOpen=officeSvg.match(/<svg\b[^>]*>/i)?.[0];
+  if(!rootOpen){console.error('OFFICE_SVG_ROOT_MISSING');process.exit(2);}
+  let nextRoot=rootOpen;
+  if(!/\bxmlns\s*=/.test(nextRoot))nextRoot=nextRoot.replace(/<svg\b/,'<svg xmlns="http://www.w3.org/2000/svg"');
+  if(!/\bwidth\s*=/.test(nextRoot))nextRoot=nextRoot.replace(/>$/,' width="'+view[2]+'" height="'+view[3]+'">');
+  officeSvg=officeSvg.replace(rootOpen,nextRoot);
+  const fontData=fs.readFileSync(font).toString('base64');
+  const style='<style>@font-face{font-family:Pretendard;src:url(data:font/woff2;base64,'+fontData+') format("woff2");font-weight:100 900}text{font-family:Pretendard,Arial,sans-serif}</style>';
+  officeSvg=officeSvg.replace(/(<svg\b[^>]*>)/i,'$1'+style);
+}
+function run(commandArgs, env={}) {
+  const r=spawnSync('agent-browser',commandArgs,{encoding:'utf8',env:{...process.env,AGENT_BROWSER_ALLOW_FILE_ACCESS:'true',...env},maxBuffer:2*1024*1024});
+  if(r.status!==0) throw new Error((r.stderr||r.stdout||'agent-browser failed').trim());
+  return (r.stdout||'').trim();
+}
+fs.mkdirSync(output,{recursive:true});
+const session='lit-diagram-export-'+process.pid+'-'+Date.now();
+const url=resolved.endsWith('.svg')?'file://'+resolved:'file://'+resolved;
+let opened=false;
+try{
+  run(['--session',session,'open',url]);opened=true;
+  run(['--session',session,'set','media','light','reduced-motion']);
+  const outputs=[];
+  const scales=all?[1,2,3]:[selected];
+  for(const scale of scales){
+    const width=Math.round(view[2]*scale), height=Math.round(view[3]*scale);
+    run(['--session',session,'set','viewport',String(Math.max(width+8,640)),String(Math.max(height+8,480))]);
+    run(['--session',session,'eval','document.fonts.ready.then(()=>true)']);
+    const script='(async()=>{const s=document.querySelector("svg");if(!s)throw new Error("SVG missing");document.documentElement.style.margin="0";document.body.style.margin="0";document.body.style.padding="0";const main=s.closest("main");if(main){main.style.width="'+width+'px";main.style.maxWidth="none";main.style.margin="0";main.style.padding="0"}s.style.width="'+width+'px";s.style.height="'+height+'px";s.style.maxWidth="none";s.style.display="block";await document.fonts.ready;const t=s.querySelector("text"),family=t?getComputedStyle(t).fontFamily:"",size=t?getComputedStyle(t).fontSize:"16px",face=[...document.fonts].find(f=>f.family.replace(/[\"\']/g,"").toLowerCase()==="pretendard"),r=s.getBoundingClientRect();const font=Boolean(t&&/Pretendard/i.test(family)&&face?.status==="loaded"&&document.fonts.check(size+" Pretendard"));return JSON.stringify({width:r.width,height:r.height,x:r.x,y:r.y,viewportWidth:innerWidth,viewportHeight:innerHeight,font,family,fontFaceStatus:face?.status||"missing"})})()';
+    const dimensions=run(['--session',session,'eval',script]);
+    let measurement;
+    try{const outer=JSON.parse(dimensions);measurement=typeof outer==='string'?JSON.parse(outer):outer;}catch{throw new Error('FONT_PROOF_INVALID '+dimensions);}
+    if(Math.abs(measurement.width-width)>0.5||Math.abs(measurement.height-height)>0.5)throw new Error('SVG_DIMENSIONS_MISMATCH '+JSON.stringify(measurement));
+    if(measurement.x<0||measurement.y<0||measurement.x+measurement.width>measurement.viewportWidth||measurement.y+measurement.height>measurement.viewportHeight)throw new Error('SVG_OUTSIDE_VIEWPORT '+JSON.stringify(measurement));
+    if(!measurement.font&&!allowFontFallback)throw new Error('PRETENDARD_NOT_LOADED_OR_COMPUTED '+JSON.stringify(measurement));
+    const filename=path.join(output,path.basename(resolved).replace(/\.(?:html|svg)$/i,'')+'-'+scale+'x.png');
+    run(['--session',session,'screenshot','svg',filename]);
+    if(!fs.existsSync(filename)||fs.statSync(filename).size===0) throw new Error('PNG_WRITE_FAILED '+filename+' '+dimensions);
+    outputs.push({file:filename,bytes:fs.statSync(filename).size,scale,dimensions});
+  }
+  for(const out of outputs) console.log('PNG '+out.scale+'x '+out.bytes+' bytes '+out.file+' '+out.dimensions);
+} catch(e) {
+  console.error('EXPORT_FAILED '+e.message);
+  process.exitCode=1;
+} finally {
+  if(opened) {
+    const close=spawnSync('agent-browser',['--session',session,'close'],{encoding:'utf8'});
+    if(close.status!==0) console.error('BROWSER_CLOSE_WARNING '+(close.stderr||''));
+  }
+}
+if(officeSvg){
+  const target=path.join(output,path.basename(resolved).replace(/\.(?:html|svg)$/i,'')+'-office.svg');
+  fs.writeFileSync(target,'<?xml version="1.0" encoding="UTF-8"?>\n'+officeSvg);
+  console.log('OFFICE_SVG '+fs.statSync(target).size+' bytes '+target+' text=live font=embedded-woff2');
+}
+if(registry) {
+  const target=path.join(output,path.basename(resolved).replace(/\.(?:html|svg)$/i,'')+'.registry.json');
+  if(!process.exitCode){fs.writeFileSync(target,JSON.stringify(registryData,null,2)+'\n');console.log('REGISTRY '+registryData.blocks.length+' blocks '+target);}
+}