locusing 0.1.2 → 0.1.3

package/dist/chunk-VPKI3XSA.mjs

@@ -0,0 +1,497 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/render-svg.ts
+function ensureKatexStyles() {
+  if (katexStyleInjected || typeof document === "undefined") return;
+  if (document.querySelector('link[href*="katex"]') || document.querySelector("style[data-katex]")) {
+    katexStyleInjected = true;
+    return;
+  }
+  const link = document.createElement("link");
+  link.rel = "stylesheet";
+  link.href = "https://cdn.jsdelivr.net/npm/katex@0.16.27/dist/katex.min.css";
+  link.crossOrigin = "anonymous";
+  document.head.appendChild(link);
+  katexStyleInjected = true;
+}
+function renderToSVG(diagram, container, options = {}) {
+  const { width = 800, height = 600, background, frame } = options;
+  ensureKatexStyles();
+  let svg;
+  if (container instanceof SVGSVGElement) {
+    svg = container;
+  } else {
+    svg = document.createElementNS(SVG_NS, "svg");
+    container.appendChild(svg);
+  }
+  svg.setAttribute("width", String(width));
+  svg.setAttribute("height", String(height));
+  while (svg.firstChild) {
+    svg.removeChild(svg.firstChild);
+  }
+  const frameConfig = frame ? typeof frame === "boolean" ? DEFAULT_FRAME : frame : null;
+  if (frameConfig) {
+    const { width: fw, height: fh } = frameConfig;
+    svg.setAttribute("viewBox", `${-fw / 2} ${-fh / 2} ${fw} ${fh}`);
+    if (background) {
+      const rect = document.createElementNS(SVG_NS, "rect");
+      rect.setAttribute("x", String(-fw / 2));
+      rect.setAttribute("y", String(-fh / 2));
+      rect.setAttribute("width", String(fw));
+      rect.setAttribute("height", String(fh));
+      rect.setAttribute("fill", background);
+      svg.appendChild(rect);
+    }
+    const defs = document.createElementNS(SVG_NS, "defs");
+    svg.appendChild(defs);
+    const flipGroup = document.createElementNS(SVG_NS, "g");
+    flipGroup.setAttribute("transform", "scale(1, -1)");
+    const element = renderShape(diagram.shape, true);
+    if (element) {
+      flipGroup.appendChild(element);
+    }
+    svg.appendChild(flipGroup);
+  } else {
+    svg.setAttribute("viewBox", `0 0 ${width} ${height}`);
+    if (background) {
+      const rect = document.createElementNS(SVG_NS, "rect");
+      rect.setAttribute("width", "100%");
+      rect.setAttribute("height", "100%");
+      rect.setAttribute("fill", background);
+      svg.appendChild(rect);
+    }
+    const defs = document.createElementNS(SVG_NS, "defs");
+    svg.appendChild(defs);
+    const element = renderShape(diagram.shape, false);
+    if (element) {
+      svg.appendChild(element);
+    }
+  }
+  return svg;
+}
+function toSVGString(diagram, options = {}) {
+  const { width = 800, height = 600, background, frame } = options;
+  const frameConfig = frame ? typeof frame === "boolean" ? DEFAULT_FRAME : frame : null;
+  if (frameConfig) {
+    const { width: fw, height: fh } = frameConfig;
+    const viewBox = `${-fw / 2} ${-fh / 2} ${fw} ${fh}`;
+    let content2 = "";
+    if (background) {
+      content2 += `<rect x="${-fw / 2}" y="${-fh / 2}" width="${fw}" height="${fh}" fill="${background}"/>`;
+    }
+    content2 += `<g transform="scale(1,-1)">${shapeToSVGString(diagram.shape)}</g>`;
+    return `<svg xmlns="${SVG_NS}" width="${width}" height="${height}" viewBox="${viewBox}">${content2}</svg>`;
+  }
+  let content = "";
+  if (background) {
+    content += `<rect width="100%" height="100%" fill="${background}"/>`;
+  }
+  content += shapeToSVGString(diagram.shape);
+  return `<svg xmlns="${SVG_NS}" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">${content}</svg>`;
+}
+function renderTexShape(shape, frameMode = false) {
+  if (frameMode) {
+    const g = document.createElementNS(SVG_NS, "g");
+    const matrix = shape.transform;
+    const a = matrix[0], c = matrix[1], tx = matrix[2];
+    const b = matrix[3], d = matrix[4], ty = matrix[5];
+    const fx = a * shape.x + c * shape.y + tx;
+    const fy = b * shape.x + d * shape.y + ty;
+    const scale = 16 / 800;
+    g.setAttribute("transform", `translate(${fx}, ${-fy}) scale(${scale}, ${-scale})`);
+    const foreignObject = document.createElementNS(SVG_NS, "foreignObject");
+    const pixelWidth = 1e3;
+    const pixelHeight = 200;
+    foreignObject.setAttribute("x", String(-pixelWidth / 2));
+    foreignObject.setAttribute("y", String(-pixelHeight / 2));
+    foreignObject.setAttribute("width", String(pixelWidth));
+    foreignObject.setAttribute("height", String(pixelHeight));
+    foreignObject.setAttribute("overflow", "visible");
+    const div = document.createElementNS(XHTML_NS, "div");
+    div.setAttribute("xmlns", XHTML_NS);
+    div.style.fontSize = `${shape.fontSize}px`;
+    div.style.color = shape.color;
+    div.style.display = "flex";
+    div.style.justifyContent = "center";
+    div.style.alignItems = "center";
+    div.style.width = `${pixelWidth}px`;
+    div.style.height = `${pixelHeight}px`;
+    div.style.whiteSpace = "nowrap";
+    div.innerHTML = shape.html;
+    foreignObject.appendChild(div);
+    g.appendChild(foreignObject);
+    return g;
+  } else {
+    const foreignObject = document.createElementNS(SVG_NS, "foreignObject");
+    foreignObject.setAttribute("x", String(shape.x));
+    foreignObject.setAttribute("y", String(shape.y));
+    foreignObject.setAttribute("width", "1000");
+    foreignObject.setAttribute("height", "200");
+    foreignObject.setAttribute("overflow", "visible");
+    const div = document.createElementNS(XHTML_NS, "div");
+    div.setAttribute("xmlns", XHTML_NS);
+    div.style.fontSize = `${shape.fontSize}px`;
+    div.style.color = shape.color;
+    div.style.display = "inline-block";
+    div.style.whiteSpace = "nowrap";
+    div.innerHTML = shape.html;
+    foreignObject.appendChild(div);
+    return foreignObject;
+  }
+}
+function renderShape(shape, frameMode = false) {
+  let element = null;
+  switch (shape.type) {
+    case "rect":
+      element = document.createElementNS(SVG_NS, "rect");
+      element.setAttribute("x", String(shape.x));
+      element.setAttribute("y", String(shape.y));
+      element.setAttribute("width", String(shape.width));
+      element.setAttribute("height", String(shape.height));
+      if (shape.rx) element.setAttribute("rx", String(shape.rx));
+      if (shape.ry) element.setAttribute("ry", String(shape.ry));
+      break;
+    case "circle":
+      element = document.createElementNS(SVG_NS, "circle");
+      element.setAttribute("cx", String(shape.cx));
+      element.setAttribute("cy", String(shape.cy));
+      element.setAttribute("r", String(shape.r));
+      break;
+    case "ellipse":
+      element = document.createElementNS(SVG_NS, "ellipse");
+      element.setAttribute("cx", String(shape.cx));
+      element.setAttribute("cy", String(shape.cy));
+      element.setAttribute("rx", String(shape.rx));
+      element.setAttribute("ry", String(shape.ry));
+      break;
+    case "line":
+      element = document.createElementNS(SVG_NS, "line");
+      element.setAttribute("x1", String(shape.x1));
+      element.setAttribute("y1", String(shape.y1));
+      element.setAttribute("x2", String(shape.x2));
+      element.setAttribute("y2", String(shape.y2));
+      break;
+    case "polyline":
+      element = document.createElementNS(SVG_NS, "polyline");
+      element.setAttribute("points", shape.points.map((p) => `${p[0]},${p[1]}`).join(" "));
+      break;
+    case "polygon":
+      element = document.createElementNS(SVG_NS, "polygon");
+      element.setAttribute("points", shape.points.map((p) => `${p[0]},${p[1]}`).join(" "));
+      break;
+    case "path":
+      element = document.createElementNS(SVG_NS, "path");
+      element.setAttribute("d", commandsToPath(shape.commands, frameMode));
+      break;
+    case "arc":
+      element = document.createElementNS(SVG_NS, "path");
+      element.setAttribute("d", arcToPath(shape.cx, shape.cy, shape.r, shape.startAngle, shape.endAngle));
+      break;
+    case "text":
+      element = document.createElementNS(SVG_NS, "text");
+      element.setAttribute("x", String(shape.x));
+      element.setAttribute("y", String(shape.y));
+      element.textContent = shape.content;
+      applyTextStyle(element, shape.style);
+      if (frameMode) {
+        const matrix = shape.transform;
+        const a = matrix[0], c = matrix[1], tx = matrix[2];
+        const b = matrix[3], d = matrix[4], ty = matrix[5];
+        const fx = a * shape.x + c * shape.y + tx;
+        const fy = b * shape.x + d * shape.y + ty;
+        element.setAttribute(
+          "transform",
+          `translate(${fx}, ${fy}) scale(1, -1) translate(${-fx}, ${-fy}) matrix(${a},${b},${c},${d},${tx},${ty})`
+        );
+      }
+      break;
+    case "tex":
+      element = renderTexShape(shape, frameMode);
+      break;
+    case "group":
+      element = document.createElementNS(SVG_NS, "g");
+      for (const child of shape.children) {
+        const childElement = renderShape(child, frameMode);
+        if (childElement) {
+          element.appendChild(childElement);
+        }
+      }
+      break;
+    case "svg":
+      element = document.createElementNS(SVG_NS, "g");
+      const svgShape = shape;
+      const parser = new DOMParser();
+      const svgDoc = parser.parseFromString(svgShape.content, "image/svg+xml");
+      const svgElement = svgDoc.querySelector("svg");
+      if (svgElement) {
+        const scaleX = shape.width / svgShape.originalWidth;
+        const scaleY = shape.height / svgShape.originalHeight;
+        element.setAttribute("transform", `scale(${scaleX}, ${scaleY})`);
+        for (const child of Array.from(svgElement.childNodes)) {
+          element.appendChild(document.importNode(child, true));
+        }
+      }
+      break;
+    case "image":
+      element = document.createElementNS(SVG_NS, "image");
+      const imgShape = shape;
+      element.setAttribute("href", imgShape.src);
+      element.setAttribute("x", String(-shape.width / 2));
+      element.setAttribute("y", String(-shape.height / 2));
+      element.setAttribute("width", String(shape.width));
+      element.setAttribute("height", String(shape.height));
+      element.setAttribute("preserveAspectRatio", "xMidYMid meet");
+      break;
+  }
+  if (element) {
+    element.setAttribute("id", shape.id);
+    applyStyle(element, shape.style);
+    if (!(frameMode && (shape.type === "text" || shape.type === "tex"))) {
+      applyTransform(element, shape.transform);
+    }
+  }
+  return element;
+}
+function shapeToSVGString(shape) {
+  const attrs = [`id="${shape.id}"`];
+  const style = styleToString(shape.style);
+  const transform = transformToString(shape.transform);
+  if (style) attrs.push(style);
+  if (transform) attrs.push(`transform="${transform}"`);
+  switch (shape.type) {
+    case "rect":
+      attrs.push(`x="${shape.x}" y="${shape.y}" width="${shape.width}" height="${shape.height}"`);
+      if (shape.rx) attrs.push(`rx="${shape.rx}"`);
+      if (shape.ry) attrs.push(`ry="${shape.ry}"`);
+      return `<rect ${attrs.join(" ")}/>`;
+    case "circle":
+      attrs.push(`cx="${shape.cx}" cy="${shape.cy}" r="${shape.r}"`);
+      return `<circle ${attrs.join(" ")}/>`;
+    case "ellipse":
+      attrs.push(`cx="${shape.cx}" cy="${shape.cy}" rx="${shape.rx}" ry="${shape.ry}"`);
+      return `<ellipse ${attrs.join(" ")}/>`;
+    case "line":
+      attrs.push(`x1="${shape.x1}" y1="${shape.y1}" x2="${shape.x2}" y2="${shape.y2}"`);
+      return `<line ${attrs.join(" ")}/>`;
+    case "polyline":
+      attrs.push(`points="${shape.points.map((p) => `${p[0]},${p[1]}`).join(" ")}"`);
+      return `<polyline ${attrs.join(" ")}/>`;
+    case "polygon":
+      attrs.push(`points="${shape.points.map((p) => `${p[0]},${p[1]}`).join(" ")}"`);
+      return `<polygon ${attrs.join(" ")}/>`;
+    case "path":
+      attrs.push(`d="${commandsToPath(shape.commands)}"`);
+      return `<path ${attrs.join(" ")}/>`;
+    case "arc":
+      attrs.push(`d="${arcToPath(shape.cx, shape.cy, shape.r, shape.startAngle, shape.endAngle)}"`);
+      return `<path ${attrs.join(" ")}/>`;
+    case "text":
+      const textStyle = textStyleToString(shape.style);
+      if (textStyle) attrs.push(textStyle);
+      attrs.push(`x="${shape.x}" y="${shape.y}"`);
+      return `<text ${attrs.join(" ")}>${escapeXML(shape.content)}</text>`;
+    case "tex":
+      const texShape = shape;
+      return `<foreignObject x="${texShape.x}" y="${texShape.y}" width="1000" height="200" overflow="visible"><div xmlns="${XHTML_NS}" style="font-size:${texShape.fontSize}px;color:${texShape.color};display:inline-block;white-space:nowrap">${texShape.html}</div></foreignObject>`;
+    case "group":
+      const children = shape.children.map(shapeToSVGString).join("");
+      return `<g ${attrs.join(" ")}>${children}</g>`;
+    case "svg":
+      const svgShapeStr = shape;
+      const scaleXStr = shape.width / svgShapeStr.originalWidth;
+      const scaleYStr = shape.height / svgShapeStr.originalHeight;
+      return `<g ${attrs.join(" ")} transform="scale(${scaleXStr}, ${scaleYStr})">${svgShapeStr.content}</g>`;
+    case "image":
+      const imgShapeStr = shape;
+      attrs.push(`href="${imgShapeStr.src}"`);
+      attrs.push(`x="${-shape.width / 2}" y="${-shape.height / 2}"`);
+      attrs.push(`width="${shape.width}" height="${shape.height}"`);
+      attrs.push('preserveAspectRatio="xMidYMid meet"');
+      return `<image ${attrs.join(" ")}/>`;
+    default:
+      return "";
+  }
+}
+function applyStyle(element, style) {
+  if (style.fill) element.setAttribute("fill", style.fill);
+  if (style.fillOpacity !== void 0) element.setAttribute("fill-opacity", String(style.fillOpacity));
+  if (style.stroke) element.setAttribute("stroke", style.stroke);
+  if (style.strokeWidth !== void 0) element.setAttribute("stroke-width", String(style.strokeWidth));
+  if (style.strokeOpacity !== void 0) element.setAttribute("stroke-opacity", String(style.strokeOpacity));
+  if (style.strokeDasharray) element.setAttribute("stroke-dasharray", style.strokeDasharray);
+  if (style.strokeLinecap) element.setAttribute("stroke-linecap", style.strokeLinecap);
+  if (style.strokeLinejoin) element.setAttribute("stroke-linejoin", style.strokeLinejoin);
+  if (style.opacity !== void 0) element.setAttribute("opacity", String(style.opacity));
+}
+function applyTextStyle(element, style) {
+  if (style.fontSize) element.setAttribute("font-size", String(style.fontSize));
+  if (style.fontFamily) element.setAttribute("font-family", style.fontFamily);
+  if (style.fontWeight) element.setAttribute("font-weight", String(style.fontWeight));
+  if (style.textAnchor) element.setAttribute("text-anchor", style.textAnchor);
+  if (style.dominantBaseline) element.setAttribute("dominant-baseline", style.dominantBaseline);
+}
+function applyTransform(element, matrix) {
+  const [a, b, c, d, e, f] = [
+    matrix[0],
+    matrix[3],
+    matrix[1],
+    matrix[4],
+    matrix[2],
+    matrix[5]
+  ];
+  if (a === 1 && b === 0 && c === 0 && d === 1 && e === 0 && f === 0) {
+    return;
+  }
+  element.setAttribute("transform", `matrix(${a},${b},${c},${d},${e},${f})`);
+}
+function styleToString(style) {
+  const parts = [];
+  if (style.fill) parts.push(`fill="${style.fill}"`);
+  if (style.fillOpacity !== void 0) parts.push(`fill-opacity="${style.fillOpacity}"`);
+  if (style.stroke) parts.push(`stroke="${style.stroke}"`);
+  if (style.strokeWidth !== void 0) parts.push(`stroke-width="${style.strokeWidth}"`);
+  if (style.strokeOpacity !== void 0) parts.push(`stroke-opacity="${style.strokeOpacity}"`);
+  if (style.strokeDasharray) parts.push(`stroke-dasharray="${style.strokeDasharray}"`);
+  if (style.strokeLinecap) parts.push(`stroke-linecap="${style.strokeLinecap}"`);
+  if (style.strokeLinejoin) parts.push(`stroke-linejoin="${style.strokeLinejoin}"`);
+  if (style.opacity !== void 0) parts.push(`opacity="${style.opacity}"`);
+  return parts.join(" ");
+}
+function textStyleToString(style) {
+  const parts = [];
+  if (style.fontSize) parts.push(`font-size="${style.fontSize}"`);
+  if (style.fontFamily) parts.push(`font-family="${style.fontFamily}"`);
+  if (style.fontWeight) parts.push(`font-weight="${style.fontWeight}"`);
+  if (style.textAnchor) parts.push(`text-anchor="${style.textAnchor}"`);
+  if (style.dominantBaseline) parts.push(`dominant-baseline="${style.dominantBaseline}"`);
+  return parts.join(" ");
+}
+function transformToString(matrix) {
+  const [a, b, c, d, e, f] = [
+    matrix[0],
+    matrix[3],
+    matrix[1],
+    matrix[4],
+    matrix[2],
+    matrix[5]
+  ];
+  if (a === 1 && b === 0 && c === 0 && d === 1 && e === 0 && f === 0) {
+    return "";
+  }
+  return `matrix(${a},${b},${c},${d},${e},${f})`;
+}
+function commandsToPath(commands, _frameMode = false) {
+  return commands.map((cmd) => {
+    switch (cmd.type) {
+      case "M":
+        return `M${cmd.x},${cmd.y}`;
+      case "L":
+        return `L${cmd.x},${cmd.y}`;
+      case "H":
+        return `H${cmd.x}`;
+      case "V":
+        return `V${cmd.y}`;
+      case "C":
+        return `C${cmd.x1},${cmd.y1} ${cmd.x2},${cmd.y2} ${cmd.x},${cmd.y}`;
+      case "S":
+        return `S${cmd.x2},${cmd.y2} ${cmd.x},${cmd.y}`;
+      case "Q":
+        return `Q${cmd.x1},${cmd.y1} ${cmd.x},${cmd.y}`;
+      case "T":
+        return `T${cmd.x},${cmd.y}`;
+      case "A": {
+        return `A${cmd.rx},${cmd.ry} ${cmd.angle} ${cmd.largeArc ? 1 : 0},${cmd.sweep ? 1 : 0} ${cmd.x},${cmd.y}`;
+      }
+      case "Z":
+        return "Z";
+    }
+  }).join(" ");
+}
+function arcToPath(cx, cy, r, startAngle, endAngle) {
+  const startX = cx + r * Math.cos(startAngle);
+  const startY = cy + r * Math.sin(startAngle);
+  const endX = cx + r * Math.cos(endAngle);
+  const endY = cy + r * Math.sin(endAngle);
+  const largeArc = Math.abs(endAngle - startAngle) > Math.PI ? 1 : 0;
+  const sweep = endAngle > startAngle ? 1 : 0;
+  return `M${startX},${startY} A${r},${r} 0 ${largeArc},${sweep} ${endX},${endY}`;
+}
+function escapeXML(str) {
+  if (typeof str !== "string") {
+    str = String(str != null ? str : "");
+  }
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+var DEFAULT_FRAME, XHTML_NS, katexStyleInjected, SVG_NS;
+var init_render_svg = __esm({
+  "src/core/render-svg.ts"() {
+    "use strict";
+    DEFAULT_FRAME = {
+      width: 16,
+      height: 9
+    };
+    XHTML_NS = "http://www.w3.org/1999/xhtml";
+    katexStyleInjected = false;
+    SVG_NS = "http://www.w3.org/2000/svg";
+  }
+});
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __objRest,
+  __esm,
+  __export,
+  __toCommonJS,
+  renderToSVG,
+  toSVGString,
+  init_render_svg
+};