@lofcz/tikz 0.3.0 → 0.3.1

package/src/recover.js

@@ -0,0 +1,255 @@
+// Conservative repairs of generated TikZ syntax, using the LaTeX lexer before
+// argument attachment. Never invent coordinates, lengths, or missing geometry.
+import { parseMinimal } from '@unified-latex/unified-latex-util-parse';
+import { printRaw } from '@unified-latex/unified-latex-util-print-raw';
+import { parsePgfkeys } from '@unified-latex/unified-latex-util-pgfkeys';
+
+const string = content => ({ type: 'string', content });
+const group = content => ({ type: 'group', content });
+const is = (node, text) => node?.type === 'string' && node.content === text;
+const space = node => node?.type === 'whitespace' || node?.type === 'parbreak';
+const skip = (nodes, i) => { while (space(nodes[i])) i++; return i; };
+function walk(nodes, visit) {
+  visit(nodes);
+  for (const node of nodes) if (Array.isArray(node.content)) walk(node.content, visit);
+}
+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;
+}
+
+const DEFINITIONS = new Set(['def', 'gdef', 'edef', 'xdef', 'let', 'newcommand', 'renewcommand', 'providecommand', 'pgfmathsetmacro', 'pgfmathtruncatemacro', 'pgfmathsetlengthmacro']);
+function extendedIdentifiers(root, source) {
+  const bindings = new Map();
+  const names = 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 [macro, tail, end] = target;
+      if (macro?.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; // keep real delimited/parameter macros
+      if (macro.position?.end.offset !== tail.position?.start.offset) continue;
+      const key = macro.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: macro.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 || !source.startsWith(binding.suffix, offset)) continue;
+        const end = offset + binding.suffix.length;
+        if (/[A-Za-z0-9_]/.test(source[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;
+      }
+    }
+  });
+}
+
+// >=Latex[length=3mm,width=2mm] needs braces around the complete arrow value;
+// TeX's optional argument scanner otherwise stops at the inner closing bracket.
+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, group(value));
+      close -= end - start - 1;
+      j = start + 1;
+    }
+    i = close;
+  }
+}
+
+function coordinateComponent(nodes, alreadyGrouped = false) {
+  const significant = nodes.filter(node => !space(node));
+  if (significant.length === 1 && significant[0].type === 'group') {
+    significant[0].content = coordinateComponent(significant[0].content, true);
+    return nodes;
+  }
+  let unitStart = significant.length - 1;
+  let unit = significant[unitStart]?.type === 'string' ? significant[unitStart].content : '';
+  if (unit.length === 1 && significant[unitStart - 1]?.type === 'string') { unitStart--; unit = significant[unitStart].content + unit; }
+  if (!/^(?:cm|mm|pt|bp|in|em|ex)$/.test(unit)) unit = null;
+  if (unit && significant.length > 1 && (significant[0].type === 'group' || significant.some(node => is(node, '(')))) {
+    const expr = significant.slice(0, unitStart).flatMap(node => node.type === 'group' ? [string('('), ...node.content, string(')')] : [node]);
+    const repaired = [string('('), ...expr, string(')*1' + unit)];
+    return alreadyGrouped ? repaired : [group(repaired)];
+  }
+  if (!alreadyGrouped && nodes.some(node => is(node, '('))) return [group(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);
+    // Calc expressions have their own coordinate parentheses inside $...$.
+    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') ? string(' and ') : inside[j]); start = j + 1;
+      }
+    }
+    segments.push(inside.slice(start));
+    // Do not reinterpret named nodes, explicit coordinate systems or projections.
+    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;
+  }
+}
+
+const PATHS = 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) };
+}
+
+/** Adapt old/shorthand tkz calls to the bundled package's explicit results. */
+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 point = delimited(nodes, options?.end ?? i + 1, '(', ')');
+    if (!point) 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, string('='));
+      }
+    }
+    if (node.content === 'tkzMidPoint') node.content = 'tkzDefMidPoint';
+    if (['tkzDefMidPoint', 'tkzDefPointBy', 'tkzDefPointWith'].includes(node.content)) {
+      const out = skip(nodes, point.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, point.end, '(', ')')) node.content = 'tkzInterCC';
+    if (node.content === 'tkzDrawCircle' && options) {
+      const keys = parsePgfkeys(options.content).map(item => (item.itemParts ?? []).map(part => printRaw(part).trim()).join('='));
+      const mode = keys.find(key => ['circum', 'in', 'diameter', 'R'].includes(key));
+      const count = point.content.filter(token => is(token, ',')).length + 1;
+      if (!mode || count !== (['circum', 'in'].includes(mode) ? 3 : 2)) continue;
+      const rest = keys.filter(key => key !== mode).join(',');
+      if (mode === 'R') {
+        const comma = point.content.findIndex(token => is(token, ','));
+        nodes.splice(i, point.end - i, string(String.raw`\draw[circle style,${rest}] (${printRaw(point.content.slice(0, comma))}) circle (${printRaw(point.content.slice(comma + 1))});`));
+        continue;
+      }
+      // tkzDefCircle supplies both center and a point on the circle. Drawing
+      // from those results preserves the construction rather than guessing a radius.
+      const replacement = String.raw`{\tkzDefCircle[${mode}](${printRaw(point.content)})\tkzGetPoints{tikzRecoveredCircleCenter}{tikzRecoveredCirclePoint}\tkzDrawCircle[${rest}](tikzRecoveredCircleCenter,tikzRecoveredCirclePoint)}`;
+      nodes.splice(i, point.end - i, string(replacement));
+    }
+  }
+}
+
+/** PGF prints numbers, not expressions; evaluate explicit arithmetic first. */
+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 at = skip(nodes, i + 1);
+      if (node.content !== 'pgfmathparse') at = skip(nodes, at + 1);
+      const expr = nodes[at];
+      if (expr?.type !== 'group') continue;
+      const mod = expr.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(expr.content.slice(0, mod)) && atom(expr.content.slice(mod + 1))) expr.content = [string('mod('), ...expr.content.slice(0, mod), string(','), ...expr.content.slice(mod + 1), string(')')];
+    }
+    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, string(String.raw`{\pgfmathparse{${printRaw(expr.content)}}\pgfmathprintnumber${options ? `[${printRaw(options.content)}]` : ''}{\pgfmathresult}}`));
+  }
+}
+
+/** A node position is one coordinate, not a path with a trailing ++ step. */
+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 base = delimited(nodes, at + 1, '(', ')');
+    if (!base) continue;
+    let plus = skip(nodes, base.end);
+    if (!is(nodes[plus], '+')) continue;
+    plus++;
+    if (is(nodes[plus], '+')) plus++;
+    const offset = delimited(nodes, plus, '(', ')');
+    if (!offset) continue;
+    nodes.splice(base.start, offset.end - base.start, string(`($(${printRaw(base.content)})+(${printRaw(offset.content)})$)`));
+  }
+}
+
+export function recoverGeneratedSyntax(source) {
+  const root = parseMinimal(source).content;
+  extendedIdentifiers(root, source);
+  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);
+}

package/src/source.js

@@ -17,6 +17,7 @@ import { printRaw } from '@unified-latex/unified-latex-util-print-raw';
 import { parsePgfkeys } from '@unified-latex/unified-latex-util-pgfkeys';
 import { BUNDLED_PACKAGES, BUNDLED_PGFPLOTS_LIBRARIES, BUNDLED_TIKZ_LIBRARIES } from './bundled.js';
 import * as T from './tables.js';
+import { recoverGeneratedSyntax } from './recover.js';
 
 export const DEFAULT_LIBRARIES = ['calc', 'intersections', 'angles', 'quotes', 'arrows.meta', 'positioning'];
 
@@ -492,11 +493,33 @@ 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];
+    // In TikZ, a named collection of keys needs /.style. PGFPlots has real
+    // setters named "tick style" etc., so leave its options alone.
+    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];
+    // A user style called name/label must not replace TikZ's node naming or
+    // labeling machinery. Keep explicit property assignments on the native key.
+    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 point = target >= 0 ? skipSpace(value, target + 1) : -1;
+      if (point >= 0 && value[point]?.type === 'inlinemath') {
+        // positioning adds the outer parentheses itself; only protect commas
+        // from the PGF key parser, which does not recognize math delimiters.
+        parts[1] = [{ type: 'group', content: value }];
+      }
+    }
     if (styleName && value) for (const node of value) if (isGroup(node)) unloopStyle(node.content, styleName);
     if (key === 'font' && value) {
       const color = pullColors(value);
@@ -535,6 +558,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; }
     const value = [...parts[1]];
     let depth = balance(value);
@@ -620,7 +653,7 @@ function processKeyLists(root, context) {
         continue;
       }
       if (node?.type === 'environment' && Array.isArray(node.args)) {
-        for (const argument of node.args) if (argument.openMark === '[') processKeyList(argument.content, context);
+        for (const argument of node.args) if (argument.openMark === '[') processKeyList(argument.content, { ...context, tikz: ['tikzpicture', 'scope', 'circuitikz'].includes(node.env) });
       }
       if (isMacro(node) && KEY_LIST_MACROS.has(node.content) && hasArgs(node)) {
         for (const argument of node.args) if (argument.openMark === '{') processKeyList(argument.content, context);
@@ -882,6 +915,20 @@ function repairForeachLists(root) {
     }
   });
 }
+
+// \boldmath expands unsafely while TikZ parses quoted labels. Move its effect
+// into the actual math expression, keeping group scope and the displayed value.
+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 = [macro('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)));
@@ -925,7 +972,7 @@ function formatNumbers(root) {
  * @returns {{ source: string, unavailable: string[], notes: string[] }}
  */
 export function prepareTikzDocument(code) {
-  const cleaned = cleanInput(code);
+  const cleaned = recoverGeneratedSyntax(cleanInput(code));
   if (!cleaned) throw new TikzSourceError('TikZ source is empty.');
   const state = {
     packages: new Map(), libraries: new Set(DEFAULT_LIBRARIES), pgfplotsLibraries: new Set(), gdLibraries: new Set(),
@@ -944,15 +991,17 @@ export function prepareTikzDocument(code) {
   const unicodeSeen = new Set();
   const colorsDefined = new Set();
   const colorsSeen = new Set();
-  for (const root of [body, statementsRoot]) {
+  const keyContext = { styleAliases: 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);
   // siunitx parses quantities itself; preserve its input grammar.
   unicodeSupport(body, unicodeSeen, unicode);
@@ -988,6 +1037,12 @@ export function prepareTikzDocument(code) {
   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, T.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(T.siunitxShim());
   if (state.shims.has('physics')) lines.push(T.PHYSICS_SHIM);
   if (state.shims.has('upgreek')) lines.push(...T.GREEK_NAMES.map(name => `\\providecommand{\\up${name}}{\\ensuremath{\\${name}}}`));

package/src/tables.js

@@ -90,7 +90,7 @@ export const AUTO_PACKAGES = [
 ];
 export const 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'],