@lofcz/tikz 0.3.0 → 0.3.1

package/dist/worker.js

@@ -802,21 +802,21 @@ var require_color_string = __commonJS({
       to: {},
       get: {}
     };
-    cs.get = function(string2) {
-      var prefix = string2.substring(0, 3).toLowerCase();
+    cs.get = function(string3) {
+      var prefix = string3.substring(0, 3).toLowerCase();
       var val;
       var model;
       switch (prefix) {
         case "hsl":
-          val = cs.get.hsl(string2);
+          val = cs.get.hsl(string3);
           model = "hsl";
           break;
         case "hwb":
-          val = cs.get.hwb(string2);
+          val = cs.get.hwb(string3);
           model = "hwb";
           break;
         default:
-          val = cs.get.rgb(string2);
+          val = cs.get.rgb(string3);
           model = "rgb";
           break;
       }
@@ -825,8 +825,8 @@ var require_color_string = __commonJS({
       }
       return { model, value: val };
     };
-    cs.get.rgb = function(string2) {
-      if (!string2) {
+    cs.get.rgb = function(string3) {
+      if (!string3) {
         return null;
       }
       var abbr = /^#([a-f0-9]{3,4})$/i;
@@ -838,7 +838,7 @@ var require_color_string = __commonJS({
       var match2;
       var i;
       var hexAlpha;
-      if (match2 = string2.match(hex)) {
+      if (match2 = string3.match(hex)) {
         hexAlpha = match2[2];
         match2 = match2[1];
         for (i = 0; i < 3; i++) {
@@ -848,7 +848,7 @@ var require_color_string = __commonJS({
         if (hexAlpha) {
           rgb[3] = parseInt(hexAlpha, 16) / 255;
         }
-      } else if (match2 = string2.match(abbr)) {
+      } else if (match2 = string3.match(abbr)) {
         match2 = match2[1];
         hexAlpha = match2[3];
         for (i = 0; i < 3; i++) {
@@ -857,7 +857,7 @@ var require_color_string = __commonJS({
         if (hexAlpha) {
           rgb[3] = parseInt(hexAlpha + hexAlpha, 16) / 255;
         }
-      } else if (match2 = string2.match(rgba)) {
+      } else if (match2 = string3.match(rgba)) {
         for (i = 0; i < 3; i++) {
           rgb[i] = parseInt(match2[i + 1], 0);
         }
@@ -868,7 +868,7 @@ var require_color_string = __commonJS({
             rgb[3] = parseFloat(match2[4]);
           }
         }
-      } else if (match2 = string2.match(per)) {
+      } else if (match2 = string3.match(per)) {
         for (i = 0; i < 3; i++) {
           rgb[i] = Math.round(parseFloat(match2[i + 1]) * 2.55);
         }
@@ -879,7 +879,7 @@ var require_color_string = __commonJS({
             rgb[3] = parseFloat(match2[4]);
           }
         }
-      } else if (match2 = string2.match(keyword)) {
+      } else if (match2 = string3.match(keyword)) {
         if (match2[1] === "transparent") {
           return [0, 0, 0, 0];
         }
@@ -898,12 +898,12 @@ var require_color_string = __commonJS({
       rgb[3] = clamp(rgb[3], 0, 1);
       return rgb;
     };
-    cs.get.hsl = function(string2) {
-      if (!string2) {
+    cs.get.hsl = function(string3) {
+      if (!string3) {
         return null;
       }
       var hsl = /^hsla?\(\s*([+-]?(?:\d{0,3}\.)?\d+)(?:deg)?\s*,?\s*([+-]?[\d\.]+)%\s*,?\s*([+-]?[\d\.]+)%\s*(?:[,|\/]\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/;
-      var match2 = string2.match(hsl);
+      var match2 = string3.match(hsl);
       if (match2) {
         var alpha = parseFloat(match2[4]);
         var h = (parseFloat(match2[1]) % 360 + 360) % 360;
@@ -914,12 +914,12 @@ var require_color_string = __commonJS({
       }
       return null;
     };
-    cs.get.hwb = function(string2) {
-      if (!string2) {
+    cs.get.hwb = function(string3) {
+      if (!string3) {
         return null;
       }
       var hwb = /^hwb\(\s*([+-]?\d{0,3}(?:\.\d+)?)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/;
-      var match2 = string2.match(hwb);
+      var match2 = string3.match(hwb);
       if (match2) {
         var alpha = parseFloat(match2[4]);
         var h = (parseFloat(match2[1]) % 360 + 360) % 360;
@@ -1450,8 +1450,8 @@ var require_conversions = __commonJS({
     };
     convert.rgb.hex = function(args) {
       const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
-      const string2 = integer.toString(16).toUpperCase();
-      return "000000".substring(string2.length) + string2;
+      const string3 = integer.toString(16).toUpperCase();
+      return "000000".substring(string3.length) + string3;
     };
     convert.hex.rgb = function(args) {
       const match2 = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
@@ -1631,8 +1631,8 @@ var require_conversions = __commonJS({
     convert.gray.hex = function(gray) {
       const val = Math.round(gray[0] / 100 * 255) & 255;
       const integer = (val << 16) + (val << 8) + val;
-      const string2 = integer.toString(16).toUpperCase();
-      return "000000".substring(string2.length) + string2;
+      const string3 = integer.toString(16).toUpperCase();
+      return "000000".substring(string3.length) + string3;
     };
     convert.rgb.gray = function(rgb) {
       const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
@@ -3350,14 +3350,14 @@ function visit(tree, visitor, options) {
     enter = visitor.enter;
     leave = visitor.leave;
   }
-  walk(tree, {
+  walk2(tree, {
     key: void 0,
     index: void 0,
     parents: [],
     containingArray: void 0,
     context: { ...startingContext }
   });
-  function walk(node, { key, index: index2, parents, context, containingArray }) {
+  function walk2(node, { key, index: index2, parents, context, containingArray }) {
     const nodePassesTest = includeArrays ? test(node, {
       key,
       index: index2,
@@ -3388,7 +3388,7 @@ function visit(tree, visitor, options) {
     })) : result;
     if (Array.isArray(node)) for (let index3 = 0; index3 > -1 && index3 < node.length; index3++) {
       const item = node[index3];
-      const result2 = walk(item, {
+      const result2 = walk2(item, {
         key,
         index: index3,
         parents,
@@ -3423,7 +3423,7 @@ function visit(tree, visitor, options) {
           newContext.inMathMode = true;
           newContext.hasMathModeAncestor = true;
         } else if (mathModeProps.leave.includes(key2)) newContext.inMathMode = false;
-        const result2 = walk(value, {
+        const result2 = walk2(value, {
           key: key2,
           index: void 0,
           parents: grandparents,
@@ -11298,10 +11298,10 @@ var pgfkeys_default = (function() {
     function peg$f8(x) {
       return x;
     }
-    function peg$f9(space, x) {
+    function peg$f9(space2, x) {
       return {
         trailingComment: x,
-        leadingParbreak: space.parbreak > 0
+        leadingParbreak: space2.parbreak > 0
       };
     }
     function peg$f10(list) {
@@ -24330,9 +24330,9 @@ function buildWordRegex(allowedSet) {
 function hasReparsableMacroNamesInArray(tree, allowedTokens) {
   for (let i = 0; i < tree.length; i++) {
     const macro3 = tree[i];
-    const string2 = tree[i + 1];
-    if (match.anyMacro(macro3) && match.anyString(string2)) {
-      if (allowedTokens.has(macro3.content.charAt(macro3.content.length - 1)) || allowedTokens.has(string2.content.charAt(0))) return true;
+    const string3 = tree[i + 1];
+    if (match.anyMacro(macro3) && match.anyString(string3)) {
+      if (allowedTokens.has(macro3.content.charAt(macro3.content.length - 1)) || allowedTokens.has(string3.content.charAt(0))) return true;
     }
   }
   return false;
@@ -24358,24 +24358,24 @@ function reparseMacroNamesInArray(tree, allowedTokens) {
   let i = 0;
   while (i < tree.length) {
     const macro3 = tree[i];
-    const string2 = tree[i + 1];
-    if (match.anyMacro(macro3) && (macro3.escapeToken == null || macro3.escapeToken === "\\") && match.anyString(string2) && (allowedTokens.has(macro3.content.charAt(macro3.content.length - 1)) || allowedTokens.has(string2.content.charAt(0)))) {
-      const match2 = string2.content.match(regex);
+    const string3 = tree[i + 1];
+    if (match.anyMacro(macro3) && (macro3.escapeToken == null || macro3.escapeToken === "\\") && match.anyString(string3) && (allowedTokens.has(macro3.content.charAt(macro3.content.length - 1)) || allowedTokens.has(string3.content.charAt(0)))) {
+      const match2 = string3.content.match(regex);
       const takeable = match2 ? match2[0] : "";
-      if (takeable.length > 0) if (takeable.length === string2.content.length) {
-        macro3.content += string2.content;
+      if (takeable.length > 0) if (takeable.length === string3.content.length) {
+        macro3.content += string3.content;
         tree.splice(i + 1, 1);
-        if (macro3.position && string2.position?.end) macro3.position.end = string2.position.end;
+        if (macro3.position && string3.position?.end) macro3.position.end = string3.position.end;
       } else {
         macro3.content += takeable;
-        string2.content = string2.content.slice(takeable.length);
+        string3.content = string3.content.slice(takeable.length);
         if (macro3.position?.end) {
           macro3.position.end.offset += takeable.length;
           macro3.position.end.column += takeable.length;
         }
-        if (string2.position?.start) {
-          string2.position.start.offset += takeable.length;
-          string2.position.start.column += takeable.length;
+        if (string3.position?.start) {
+          string3.position.start.offset += takeable.length;
+          string3.position.start.column += takeable.length;
         }
       }
       else i++;
@@ -24803,7 +24803,7 @@ var AUTO_PACKAGES = [
 ];
 var AUTO_LIBRARIES = [
   [/\bmatrix of (?:math )?nodes\b|\\matrix\b/, "matrix"],
-  [/\b(?:regular polygon|trapezium|semicircle|isosceles triangle|kite|dart|circular sector|cylinder|diamond|star|ellipse)\s*[,\]=]/, "shapes.geometric"],
+  [/\b(?:regular polygon|trapezium|parallelogram|semicircle|isosceles triangle|kite|dart|circular sector|cylinder|diamond|star|ellipse)\s*[,\]=]/, "shapes.geometric"],
   [/\b(?:cross out|strike out|rounded rectangle|chamfered rectangle)\b/, "shapes.misc"],
   [/\b(?:cloud|forbidden sign|magnifying glass|starburst|signal|tape|magnetic tape|correct forbidden sign)\s*[,\]=]/, "shapes.symbols"],
   [/\b(?:rectangle split|circle split|ellipse split)\b/, "shapes.multipart"],
@@ -25266,6 +25266,265 @@ var TEXT_ARG_MACROS = /* @__PURE__ */ new Set(["textbf", "textit", "emph", "unde
 var SHAPE_NAMES = /* @__PURE__ */ new Set(["rectangle", "circle", "coordinate", "ellipse", "diamond", "trapezium", "semicircle", "regular polygon", "star", "isosceles triangle", "kite", "dart", "circular sector", "cylinder", "cloud", "starburst", "signal", "tape", "magnifying glass", "forbidden sign", "magnetic tape", "cross out", "strike out", "rounded rectangle", "chamfered rectangle", "rectangle split", "circle split", "circle solidus", "ellipse split", "rectangle callout", "ellipse callout", "cloud callout", "arrow box", "single arrow", "double arrow", "circle ee", "circle wee", "cross", "ground", "generic circle IEC", "generic diode IEC", "and gate", "or gate", "nand gate", "nor gate", "xor gate", "xnor gate", "not gate", "buffer gate"]);
 var MACRO_TYPOS = { circC: "\\circ\\mathrm{C}", degreeC: "^\\circ\\mathrm{C}", textcelsius: "\\celsius", textdegreeC: "\\textdegree C" };
 
+// src/recover.js
+var string2 = (content) => ({ type: "string", content });
+var group2 = (content) => ({ type: "group", content });
+var is = (node, text) => node?.type === "string" && node.content === text;
+var space = (node) => node?.type === "whitespace" || node?.type === "parbreak";
+var skip = (nodes, i) => {
+  while (space(nodes[i])) i++;
+  return i;
+};
+function walk(nodes, visit2) {
+  visit2(nodes);
+  for (const node of nodes) if (Array.isArray(node.content)) walk(node.content, visit2);
+}
+function closeAt(nodes, start, open, close) {
+  let depth = 0;
+  for (let i = start; i < nodes.length; i++) {
+    if (is(nodes[i], open)) depth++;
+    else if (is(nodes[i], close) && --depth === 0) return i;
+  }
+  return -1;
+}
+var DEFINITIONS = /* @__PURE__ */ new Set(["def", "gdef", "edef", "xdef", "let", "newcommand", "renewcommand", "providecommand", "pgfmathsetmacro", "pgfmathtruncatemacro", "pgfmathsetlengthmacro"]);
+function extendedIdentifiers(root, source2) {
+  const bindings = /* @__PURE__ */ new Map();
+  const names = /* @__PURE__ */ new Set();
+  walk(root, (nodes) => {
+    for (const node of nodes) if (node.type === "macro") names.add(node.content);
+  });
+  walk(root, (nodes) => {
+    for (let i = 0; i < nodes.length; i++) {
+      if (nodes[i].type !== "macro" || !DEFINITIONS.has(nodes[i].content)) continue;
+      const at = skip(nodes, i + 1);
+      const target = nodes[at]?.type === "group" ? nodes[at].content : nodes.slice(at, at + 3);
+      const [macro3, tail, end] = target;
+      if (macro3?.type !== "macro" || tail?.type !== "string" || !/^(?:_[A-Za-z0-9_]+|[0-9][A-Za-z0-9_]*)$/.test(tail.content)) continue;
+      if (end && end.type !== "group" && !(nodes[i].content === "let" && end.type === "macro")) continue;
+      if (macro3.position?.end.offset !== tail.position?.start.offset) continue;
+      const key = macro3.content + tail.content;
+      if (bindings.has(key)) continue;
+      let name = "tikzRecoveredVariable";
+      let n = bindings.size;
+      do {
+        name += String.fromCharCode(65 + n % 26);
+        n = Math.floor(n / 26);
+      } while (n);
+      while (names.has(name)) name += "X";
+      names.add(name);
+      bindings.set(key, { base: macro3.content, suffix: tail.content, name });
+    }
+  });
+  if (!bindings.size) return;
+  walk(root, (nodes) => {
+    for (let i = 0; i + 1 < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.type !== "macro") continue;
+      for (const binding of bindings.values()) {
+        const offset = node.position?.end.offset;
+        if (node.content !== binding.base || !source2.startsWith(binding.suffix, offset)) continue;
+        const end = offset + binding.suffix.length;
+        if (/[A-Za-z0-9_]/.test(source2[end] ?? "")) continue;
+        let j = i + 1;
+        while (j < nodes.length && nodes[j].position?.end.offset <= end) j++;
+        if (nodes[j - 1]?.position?.end.offset !== end) continue;
+        node.content = binding.name;
+        nodes.splice(i + 1, j - i - 1);
+        break;
+      }
+    }
+  });
+}
+function nestedOptions(nodes) {
+  for (let i = 0; i < nodes.length; i++) {
+    if (!is(nodes[i], "[")) continue;
+    let close = closeAt(nodes, i, "[", "]");
+    if (close < 0) continue;
+    for (let j = i + 1; j < close; j++) {
+      if (!is(nodes[j], "[")) continue;
+      const end = closeAt(nodes, j, "[", "]");
+      let start = j - 1;
+      while (start > i && !is(nodes[start], "=") && !is(nodes[start], ",")) start--;
+      if (end < 0 || !is(nodes[start], "=")) continue;
+      const value = nodes.slice(start + 1, end + 1);
+      nodes.splice(start + 1, end - start, group2(value));
+      close -= end - start - 1;
+      j = start + 1;
+    }
+    i = close;
+  }
+}
+function coordinateComponent(nodes, alreadyGrouped = false) {
+  const significant2 = nodes.filter((node) => !space(node));
+  if (significant2.length === 1 && significant2[0].type === "group") {
+    significant2[0].content = coordinateComponent(significant2[0].content, true);
+    return nodes;
+  }
+  let unitStart = significant2.length - 1;
+  let unit = significant2[unitStart]?.type === "string" ? significant2[unitStart].content : "";
+  if (unit.length === 1 && significant2[unitStart - 1]?.type === "string") {
+    unitStart--;
+    unit = significant2[unitStart].content + unit;
+  }
+  if (!/^(?:cm|mm|pt|bp|in|em|ex)$/.test(unit)) unit = null;
+  if (unit && significant2.length > 1 && (significant2[0].type === "group" || significant2.some((node) => is(node, "(")))) {
+    const expr = significant2.slice(0, unitStart).flatMap((node) => node.type === "group" ? [string2("("), ...node.content, string2(")")] : [node]);
+    const repaired = [string2("("), ...expr, string2(")*1" + unit)];
+    return alreadyGrouped ? repaired : [group2(repaired)];
+  }
+  if (!alreadyGrouped && nodes.some((node) => is(node, "("))) return [group2(nodes)];
+  return nodes;
+}
+function coordinates(nodes) {
+  for (let i = 0; i < nodes.length; i++) {
+    if (nodes[i].type === "inlinemath") {
+      coordinates(nodes[i].content);
+      continue;
+    }
+    if (!is(nodes[i], "(")) continue;
+    const end = closeAt(nodes, i, "(", ")");
+    if (end < 0) continue;
+    const inside = nodes.slice(i + 1, end);
+    if (inside.some((node) => node.type === "inlinemath")) {
+      for (const node of inside) if (node.type === "inlinemath") coordinates(node.content);
+      i = end;
+      continue;
+    }
+    let depth = 0, start = 0;
+    const segments = [], delimiters = [];
+    for (let j = 0; j < inside.length; j++) {
+      if (is(inside[j], "(")) depth++;
+      else if (is(inside[j], ")")) depth--;
+      else if (!depth && (is(inside[j], ",") || is(inside[j], ":") || is(inside[j], "and"))) {
+        segments.push(inside.slice(start, j));
+        delimiters.push(is(inside[j], "and") ? string2(" and ") : inside[j]);
+        start = j + 1;
+      }
+    }
+    segments.push(inside.slice(start));
+    if (inside.some((node) => is(node, "=") || is(node, "|") || is(node, "cs"))) {
+      i = end;
+      continue;
+    }
+    const rebuilt = segments.flatMap((part, j) => [...coordinateComponent(part), ...delimiters[j] ? [delimiters[j]] : []]);
+    nodes.splice(i + 1, end - i - 1, ...rebuilt);
+    i += rebuilt.length + 1;
+  }
+}
+var PATHS = /* @__PURE__ */ new Set(["draw", "fill", "filldraw", "shade", "shadedraw", "path", "coordinate", "node", "clip", "pic"]);
+function delimited(nodes, at, open, close) {
+  at = skip(nodes, at);
+  if (!is(nodes[at], open)) return null;
+  const end = closeAt(nodes, at, open, close);
+  return end < 0 ? null : { start: at, end: end + 1, content: nodes.slice(at + 1, end) };
+}
+function tkzCommands(nodes) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.type !== "macro" || !node.content.startsWith("tkz")) continue;
+    const options = delimited(nodes, i + 1, "[", "]");
+    const point2 = delimited(nodes, options?.end ?? i + 1, "(", ")");
+    if (!point2) continue;
+    if (node.content === "tkzDefLine" && options) {
+      const first = skip(options.content, 0);
+      const through = skip(options.content, first + 1);
+      if (["orthogonal", "perpendicular", "parallel"].some((key) => is(options.content[first], key)) && is(options.content[through], "through")) {
+        nodes.splice(options.start + 1 + first + 1, 0, string2("="));
+      }
+    }
+    if (node.content === "tkzMidPoint") node.content = "tkzDefMidPoint";
+    if (["tkzDefMidPoint", "tkzDefPointBy", "tkzDefPointWith"].includes(node.content)) {
+      const out = skip(nodes, point2.end);
+      if (nodes[out]?.type === "group") nodes.splice(out, 0, { type: "macro", content: "tkzGetPoint" });
+      if (node.content === "tkzDefPointBy" && options) {
+        const onto = options.content.findIndex((token) => is(token, "onto"));
+        const line = skip(options.content, onto + 1);
+        if (onto >= 0 && is(options.content[line], "line")) {
+          options.content.splice(line, 1);
+          nodes.splice(options.start + 1, options.end - options.start - 2, ...options.content);
+        }
+      }
+    }
+    if (node.content === "tkzInter" && options && printRaw(options.content).trim() === "R" && delimited(nodes, point2.end, "(", ")")) node.content = "tkzInterCC";
+    if (node.content === "tkzDrawCircle" && options) {
+      const keys2 = parsePgfkeys(options.content).map((item) => (item.itemParts ?? []).map((part) => printRaw(part).trim()).join("="));
+      const mode = keys2.find((key) => ["circum", "in", "diameter", "R"].includes(key));
+      const count = point2.content.filter((token) => is(token, ",")).length + 1;
+      if (!mode || count !== (["circum", "in"].includes(mode) ? 3 : 2)) continue;
+      const rest = keys2.filter((key) => key !== mode).join(",");
+      if (mode === "R") {
+        const comma = point2.content.findIndex((token) => is(token, ","));
+        nodes.splice(i, point2.end - i, string2(String.raw`\draw[circle style,${rest}] (${printRaw(point2.content.slice(0, comma))}) circle (${printRaw(point2.content.slice(comma + 1))});`));
+        continue;
+      }
+      const replacement = String.raw`{\tkzDefCircle[${mode}](${printRaw(point2.content)})\tkzGetPoints{tikzRecoveredCircleCenter}{tikzRecoveredCirclePoint}\tkzDrawCircle[${rest}](tikzRecoveredCircleCenter,tikzRecoveredCirclePoint)}`;
+      nodes.splice(i, point2.end - i, string2(replacement));
+    }
+  }
+}
+function numberExpressions(nodes) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.type !== "macro") continue;
+    if (["pgfmathparse", "pgfmathsetmacro", "pgfmathtruncatemacro"].includes(node.content)) {
+      let at2 = skip(nodes, i + 1);
+      if (node.content !== "pgfmathparse") at2 = skip(nodes, at2 + 1);
+      const expr2 = nodes[at2];
+      if (expr2?.type !== "group") continue;
+      const mod = expr2.content.findIndex((token) => is(token, "mod"));
+      const atom = (tokens) => {
+        const value = tokens.filter((token) => !space(token));
+        return value.length === 1 && (value[0].type === "macro" || value[0].type === "group" || value[0].type === "string" && /^-?\d+(?:\.\d+)?$/.test(value[0].content));
+      };
+      if (mod > 0 && atom(expr2.content.slice(0, mod)) && atom(expr2.content.slice(mod + 1))) expr2.content = [string2("mod("), ...expr2.content.slice(0, mod), string2(","), ...expr2.content.slice(mod + 1), string2(")")];
+    }
+    if (node.content !== "pgfmathprintnumber") continue;
+    const options = delimited(nodes, i + 1, "[", "]");
+    const at = skip(nodes, options?.end ?? i + 1);
+    const expr = nodes[at];
+    if (expr?.type !== "group" || !expr.content.some((token) => token.type === "string" && ["*", "/", "+", "("].includes(token.content))) continue;
+    nodes.splice(i, at - i + 1, string2(String.raw`{\pgfmathparse{${printRaw(expr.content)}}\pgfmathprintnumber${options ? `[${printRaw(options.content)}]` : ""}{\pgfmathresult}}`));
+  }
+}
+function relativeNodePosition(nodes) {
+  for (let i = 0; i < nodes.length; i++) {
+    if (nodes[i].type !== "macro" || nodes[i].content !== "node") continue;
+    let at = i + 1;
+    while (at < nodes.length && !is(nodes[at], "at") && !is(nodes[at], ";")) at++;
+    if (!is(nodes[at], "at")) continue;
+    const base2 = delimited(nodes, at + 1, "(", ")");
+    if (!base2) continue;
+    let plus = skip(nodes, base2.end);
+    if (!is(nodes[plus], "+")) continue;
+    plus++;
+    if (is(nodes[plus], "+")) plus++;
+    const offset = delimited(nodes, plus, "(", ")");
+    if (!offset) continue;
+    nodes.splice(base2.start, offset.end - base2.start, string2(`($(${printRaw(base2.content)})+(${printRaw(offset.content)})$)`));
+  }
+}
+function recoverGeneratedSyntax(source2) {
+  const root = parseMinimal(source2).content;
+  extendedIdentifiers(root, source2);
+  walk(root, nestedOptions);
+  walk(root, tkzCommands);
+  walk(root, numberExpressions);
+  walk(root, relativeNodePosition);
+  walk(root, (nodes) => {
+    for (let i = 0; i < nodes.length; i++) {
+      if (nodes[i].type !== "macro" || !PATHS.has(nodes[i].content)) continue;
+      let end = i + 1;
+      while (end < nodes.length && !is(nodes[end], ";")) end++;
+      const tokens = nodes.slice(i + 1, end);
+      coordinates(tokens);
+      nodes.splice(i + 1, end - i - 1, ...tokens);
+      i += tokens.length;
+    }
+  });
+  return printRaw(root);
+}
+
 // src/source.js
 var DEFAULT_LIBRARIES = ["calc", "intersections", "angles", "quotes", "arrows.meta", "positioning"];
 var TikzSourceError = class extends Error {
@@ -25305,8 +25564,8 @@ function definedMacroNames(text) {
           if (isMacro(array[j])) names.add(array[j].content);
         }
       } else if (node.content === "tikzmath") {
-        const group2 = array[skipSpace(array, i + 1)];
-        if (isGroup(group2)) walkArrays(group2.content, (tokens) => {
+        const group3 = array[skipSpace(array, i + 1)];
+        if (isGroup(group3)) walkArrays(group3.content, (tokens) => {
           for (let j = 0; j < tokens.length; j++) if (isMacro(tokens[j]) && isString(tokens[skipSpace(tokens, j + 1)], "=")) names.add(tokens[j].content);
         });
       } else if (node.content === "pgfkeysgetvalue") {
@@ -25719,13 +25978,29 @@ function processKeyList(nodes, context) {
   for (const item of items) {
     const parts = item.itemParts ?? [];
     if (!parts.length) continue;
-    const key = printRaw(parts[0]).trim();
+    let key = printRaw(parts[0]).trim();
     const value = parts[1];
+    if (context.tikz && !key.includes("/") && key.endsWith(" style") && value?.some(isGroup)) {
+      key += "/.style";
+      parts[0] = [str(key)];
+    }
     if (value && TEXT_KEYS.has(key)) repairTextNodes(value, context);
     if (value && /^(?:xtick|ytick|ztick)labels$|^legend entries$/.test(key)) {
       for (const node of value) if (isGroup(node)) repairTextNodes(node.content, context);
     }
     const styleName = /^(.+?)\/\.(?:style|append style)$/.exec(key)?.[1];
+    if (styleName && ["name", "label"].includes(styleName)) {
+      const alias = `tikz recovered ${styleName} style`;
+      context.styleAliases?.set(styleName, alias);
+      parts[0] = [str(key.replace(styleName, alias))];
+    } else if (!value && context.styleAliases?.has(key)) parts[0] = [str(context.styleAliases.get(key))];
+    if (value && /^(above|below|left|right)( left| right)?$/.test(key)) {
+      const target = value.findIndex((node) => isString(node, "of"));
+      const point2 = target >= 0 ? skipSpace(value, target + 1) : -1;
+      if (point2 >= 0 && value[point2]?.type === "inlinemath") {
+        parts[1] = [{ type: "group", content: value }];
+      }
+    }
     if (styleName && value) {
       for (const node of value) if (isGroup(node)) unloopStyle(node.content, styleName);
     }
@@ -25775,6 +26050,16 @@ function mergeParenthesisedValues(items) {
   for (let i = 0; i < items.length; i++) {
     const item = items[i];
     const parts = item.itemParts ?? [];
+    if (parts.length === 2 && /^(above|below|left|right)( left| right)?$/.test(printRaw(parts[0]).trim())) {
+      const of = parts[1].findIndex((node) => isString(node, "of"));
+      const number = (tokens) => /^-?\d+(?:\.\d+)?(?:cm|mm|pt)?$/.test(printRaw(tokens).trim());
+      const next = items[i + 1]?.itemParts;
+      if (of >= 0 && number(parts[1].slice(of + 1)) && next?.length === 1 && number(next[0])) {
+        out.push({ ...item, itemParts: [parts[0], [{ type: "group", content: [...parts[1], str(","), ...next[0]] }]] });
+        i++;
+        continue;
+      }
+    }
     if (parts.length !== 2 || balance(parts[1]) <= 0) {
       out.push(item);
       continue;
@@ -25869,7 +26154,7 @@ function processKeyLists(root, context) {
         continue;
       }
       if (node?.type === "environment" && Array.isArray(node.args)) {
-        for (const argument2 of node.args) if (argument2.openMark === "[") processKeyList(argument2.content, context);
+        for (const argument2 of node.args) if (argument2.openMark === "[") processKeyList(argument2.content, { ...context, tikz: ["tikzpicture", "scope", "circuitikz"].includes(node.env) });
       }
       if (isMacro(node) && KEY_LIST_MACROS.has(node.content) && hasArgs(node)) {
         for (const argument2 of node.args) if (argument2.openMark === "{") processKeyList(argument2.content, context);
@@ -26136,6 +26421,25 @@ function repairForeachLists(root) {
     }
   });
 }
+function repairBoldMath(root) {
+  walkArrays(root, (array) => {
+    if (!array.some((node) => node.type === "inlinemath")) return;
+    let bold = false;
+    for (let i = 0; i < array.length; i++) {
+      if (isMacro(array[i], "boldmath")) {
+        bold = true;
+        array.splice(i--, 1);
+        continue;
+      }
+      if (isMacro(array[i], "unboldmath")) {
+        bold = false;
+        array.splice(i--, 1);
+        continue;
+      }
+      if (bold && array[i].type === "inlinemath") array[i].content = [macro2("boldsymbol", [{ type: "argument", openMark: "{", closeMark: "}", content: array[i].content }])];
+    }
+  });
+}
 function mathOnly(nodes) {
   if (nodes.some((node) => node.type === "inlinemath" || node.type === "displaymath")) return false;
   return needsMath(nodes.filter((node) => !isSpace(node)));
@@ -26158,7 +26462,7 @@ function stripOverlayKeys(root) {
   }
 }
 function prepareTikzDocument(code) {
-  const cleaned = cleanInput(code);
+  const cleaned = recoverGeneratedSyntax(cleanInput(code));
   if (!cleaned) throw new TikzSourceError("TikZ source is empty.");
   const state = {
     packages: /* @__PURE__ */ new Map(),
@@ -26180,15 +26484,17 @@ function prepareTikzDocument(code) {
   const unicodeSeen = /* @__PURE__ */ new Set();
   const colorsDefined = /* @__PURE__ */ new Set();
   const colorsSeen = /* @__PURE__ */ new Set();
-  for (const root of [body, statementsRoot]) {
+  const keyContext = { styleAliases: /* @__PURE__ */ new Map() };
+  for (const root of [statementsRoot, body]) {
     rewriteHexColors(root);
     replaceUnavailableMacros(root, state);
-    processKeyLists(root, {});
+    processKeyLists(root, keyContext);
   }
   stripOverlayKeys(body);
   protectAndDelimiter(body);
   repairForeachLists(body);
   replaceTypos(body);
+  repairBoldMath(body);
   repairNodeTexts(body);
   unicodeSupport(body, unicodeSeen, unicode);
   unicodeSupport(statementsRoot, unicodeSeen, unicode);
@@ -26223,6 +26529,12 @@ ${declarations}`);
   if (state.gdLibraries.size) lines.push(`\\usegdlibrary{${[...state.gdLibraries].join(",")}}`);
   if (state.packages.has("pgfplots") && !state.compat) lines.push("\\pgfplotsset{compat=1.18}");
   lines.push(...unicode, ...colors, COMPAT_SHIM);
+  if (!excluded.has("pgfmathdistance") && /\\pgfmathdistance\b/.test(everything)) lines.push(String.raw`\makeatletter
+\providecommand{\pgfmathdistance}[2]{\pgfpointdiff{#1}{#2}\pgfmathveclen{\the\pgf@x}{\the\pgf@y}}
+\makeatother`);
+  if (/\bparallelogram\b/.test(everything)) lines.push(String.raw`\pgfkeysifdefined{/tikz/parallelogram/.@cmd}{}{\tikzset{parallelogram/.style={shape=trapezium,trapezium left angle=70,trapezium right angle=110}}}`);
+  lines.push(String.raw`\pgfkeysifdefined{/tikz/rounded cap/.@cmd}{}{\tikzset{rounded cap/.style={line cap=round}}}
+\pgfkeysifdefined{/tikz/final/.@cmd}{}{\tikzset{final/.style={accepting}}}`);
   if (state.shims.has("siunitx")) lines.push(siunitxShim());
   if (state.shims.has("physics")) lines.push(PHYSICS_SHIM);
   if (state.shims.has("upgreek")) lines.push(...GREEK_NAMES.map((name) => `\\providecommand{\\up${name}}{\\ensuremath{\\${name}}}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lofcz/tikz",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Self-contained, process-isolated TikZ to SVG rendering powered by mp-tikz-wasm.",
   "type": "module",
   "license": "GPL-3.0-or-later",