@lydt/geogebra-studio 0.0.0-stage → 0.4.0-rc.2

package/dist/gikz-browser.js

@@ -0,0 +1,770 @@
+"use strict";
+(() => {
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __commonJS = (cb, mod) => function __require() {
+    try {
+      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    } catch (e) {
+      throw mod = 0, e;
+    }
+  };
+
+  // gikz/core.cjs
+  var require_core = __commonJS({
+    "gikz/core.cjs"(exports, module) {
+      "use strict";
+      function roundToThreeDecimals(num) {
+        return Math.round(num * 1e3) / 1e3;
+      }
+      function formatCoordinate(coordStr, shouldRound) {
+        const match = coordStr.match(/\(([^,]+),([^)]+)\)/);
+        if (!match) return coordStr;
+        let x = parseFloat(match[1]);
+        let y = parseFloat(match[2]);
+        if (shouldRound) {
+          x = roundToThreeDecimals(x);
+          y = roundToThreeDecimals(y);
+        }
+        return `(${x},${y})`;
+      }
+      function getSmartLabelPosition(x, y, allPoints) {
+        const xCoords = allPoints.map((p) => p.x);
+        const yCoords = allPoints.map((p) => p.y);
+        const minX = Math.min(...xCoords);
+        const maxX = Math.max(...xCoords);
+        const minY = Math.min(...yCoords);
+        const maxY = Math.max(...yCoords);
+        const centerX = (minX + maxX) / 2;
+        const centerY = (minY + maxY) / 2;
+        let position = "above";
+        if (Math.abs(x - minX) < 0.1) {
+          position = "left";
+        } else if (Math.abs(x - maxX) < 0.1) {
+          position = "right";
+        } else if (Math.abs(y - minY) < 0.1) {
+          position = "below";
+        } else if (Math.abs(y - maxY) < 0.1) {
+          position = "above";
+        } else {
+          if (x > centerX && y > centerY) position = "above right";
+          else if (x > centerX && y <= centerY) position = "below right";
+          else if (x <= centerX && y > centerY) position = "above left";
+          else position = "below left";
+        }
+        return position;
+      }
+      var convertLineStyle = (style) => {
+        if (!style) return "";
+        let lineStyle = style.replace(/line width=[^,\]]+,?/g, "");
+        lineStyle = lineStyle.replace(/,\s*$/g, "");
+        lineStyle = lineStyle.replace(/\[\s*,\s*/g, "[");
+        if (lineStyle.includes("dash pattern=on 1pt off 1pt on 1pt off 4pt")) return "dash dot";
+        if (lineStyle.includes("dash pattern=on 1pt off 1pt")) return "dashed";
+        if (lineStyle.includes("dotted")) return "dotted";
+        if (lineStyle.includes("dash")) return "dashed";
+        return "";
+      };
+      function extractQuadraticFunctions(code, shouldRound) {
+        try {
+          const quadraticRegex = /\\draw\s*\[([^\]]+)\]\s*plot\s*\(\\x,\{\(\\x\)\^2\/2\/([^}]+)\}\)/g;
+          const quadraticMatches = [...code.matchAll(quadraticRegex)];
+          const quadraticFunctions = [];
+          quadraticMatches.forEach((match) => {
+            const options = match[1];
+            let denominator = match[2];
+            const samplesMatch = options.match(/samples=(\d+)/);
+            const rotateMatch = options.match(/rotate around=\{([^:]+):\(([^,]+),([^)]+)\)\}/);
+            const xshiftMatch = options.match(/xshift=([^,]+)cm/);
+            const yshiftMatch = options.match(/yshift=([^,]+)cm/);
+            const domainMatch = options.match(/domain=([^:)]+):([^)]+)\)?/);
+            if (domainMatch) {
+              let angle = "0", centerX = "0", centerY = "0";
+              if (rotateMatch) {
+                angle = rotateMatch[1];
+                centerX = rotateMatch[2];
+                centerY = rotateMatch[3];
+              }
+              let xshift = "0", yshift = "0";
+              if (xshiftMatch) xshift = xshiftMatch[1];
+              if (yshiftMatch) yshift = yshiftMatch[1];
+              let domainStart = domainMatch[1];
+              let domainEnd = domainMatch[2];
+              if (domainEnd.includes(")")) domainEnd = domainEnd.replace(")", "");
+              if (shouldRound) {
+                if (centerX !== "0") centerX = roundToThreeDecimals(parseFloat(centerX));
+                if (centerY !== "0") centerY = roundToThreeDecimals(parseFloat(centerY));
+                if (xshift !== "0") xshift = roundToThreeDecimals(parseFloat(xshift));
+                if (yshift !== "0") yshift = roundToThreeDecimals(parseFloat(yshift));
+                denominator = roundToThreeDecimals(parseFloat(denominator));
+                domainStart = roundToThreeDecimals(parseFloat(domainStart));
+                domainEnd = roundToThreeDecimals(parseFloat(domainEnd));
+                xshift += "cm";
+                yshift += "cm";
+              }
+              let newOptions = "smooth,samples=500";
+              if (rotateMatch) newOptions += `,rotate around={${angle}:(${centerX},${centerY})}`;
+              if (xshiftMatch && xshift !== "0cm" || yshiftMatch && yshift !== "0cm")
+                newOptions += `,xshift=${xshift},yshift=${yshift}`;
+              newOptions += `,domain=${domainStart}:${domainEnd}`;
+              quadraticFunctions.push({ original: match[0], options: newOptions, expression: `(\\x)^2/2/${denominator}` });
+            }
+          });
+          return { hasQuadratic: quadraticFunctions.length > 0, quadraticFunctions };
+        } catch (error) {
+          return { hasQuadratic: false, quadraticFunctions: [] };
+        }
+      }
+      function extractFunctionPlots(code, shouldRound) {
+        try {
+          const clipRegex = /\\clip\(([^,]+),([^)]+)\)\s*rectangle\s*\(([^,]+),([^)]+)\);/;
+          const clipMatch = code.match(clipRegex);
+          if (!clipMatch) {
+            return { hasFunctions: false, scopeCode: "", clipArea: "", normalFunctionCount: 0, quadraticFunctionCount: 0 };
+          }
+          const clipX1 = shouldRound ? roundToThreeDecimals(parseFloat(clipMatch[1])) : parseFloat(clipMatch[1]);
+          const clipY1 = shouldRound ? roundToThreeDecimals(parseFloat(clipMatch[2])) : parseFloat(clipMatch[2]);
+          const clipX2 = shouldRound ? roundToThreeDecimals(parseFloat(clipMatch[3])) : parseFloat(clipMatch[3]);
+          const clipY2 = shouldRound ? roundToThreeDecimals(parseFloat(clipMatch[4])) : parseFloat(clipMatch[4]);
+          const functionPlotRegex = /\\draw\[([^\]]*)\]\s*plot\s*\(\\x,\{([^}]*)\}\)/g;
+          const functionMatches = [...code.matchAll(functionPlotRegex)];
+          const functions = [];
+          const containsLnRegex = /ln\s*\(/i;
+          functionMatches.forEach((match) => {
+            const options = match[1];
+            const functionExpression = match[2];
+            const domainRegex = /domain=([^:]+):([^,\]]+)/;
+            const domainMatch = options.match(domainRegex);
+            if (domainMatch) {
+              let domainStart = domainMatch[1], domainEnd = domainMatch[2];
+              if (containsLnRegex.test(functionExpression)) {
+                if (Math.abs(parseFloat(domainStart)) < 1e-3) domainStart = "0.001";
+              }
+              if (shouldRound) {
+                const s = parseFloat(domainStart), e = parseFloat(domainEnd);
+                if (!isNaN(s)) domainStart = roundToThreeDecimals(s).toString();
+                if (!isNaN(e)) domainEnd = roundToThreeDecimals(e).toString();
+              }
+              let lineStyle = "";
+              if (options.includes("dash pattern=on 1pt off 1pt on 1pt off 4pt")) lineStyle = "dash dot";
+              else if (options.includes("dash pattern=on 1pt off 1pt")) lineStyle = "dashed";
+              else if (options.includes("dotted")) lineStyle = "dotted";
+              let newOptions = "smooth,samples=500";
+              if (lineStyle) newOptions = lineStyle + "," + newOptions;
+              functions.push({ original: match[0], options: newOptions, domainStart, domainEnd, expression: functionExpression, lineStyle });
+            }
+          });
+          const quadraticResult = extractQuadraticFunctions(code, shouldRound);
+          let result = "  \\begin{scope}\n";
+          result += `    \\clip(${clipX1},${clipY1}) rectangle (${clipX2},${clipY2});
+`;
+          functions.forEach((func) => {
+            result += `    \\draw[${func.options},domain=${func.domainStart}:${func.domainEnd}] plot(\\x,{${func.expression}});
+`;
+          });
+          if (quadraticResult.hasQuadratic) {
+            quadraticResult.quadraticFunctions.forEach((quad) => {
+              result += `    \\draw[${quad.options}] plot(\\x,{${quad.expression}});
+`;
+            });
+          }
+          result += "  \\end{scope}\n";
+          return {
+            hasFunctions: functions.length > 0 || quadraticResult.hasQuadratic,
+            scopeCode: result,
+            clipArea: `(${clipX1},${clipY1}) rectangle (${clipX2},${clipY2})`,
+            normalFunctionCount: functions.length,
+            quadraticFunctionCount: quadraticResult.quadraticFunctions.length
+          };
+        } catch (error) {
+          return { hasFunctions: false, scopeCode: "", clipArea: "", normalFunctionCount: 0, quadraticFunctionCount: 0 };
+        }
+      }
+      function extractParametricPlots(code, shouldRound) {
+        try {
+          const parametricRegex = /\\draw\[([^\]]*)\]\s*plot\[parametric\]\s*function\{([^}]+)\};/g;
+          const matches = [...code.matchAll(parametricRegex)];
+          const plots = [];
+          matches.forEach((match) => {
+            const options = match[1];
+            const functionStr = match[2];
+            const commaMatch = functionStr.match(/([^,]+),([^,]+)/);
+            if (!commaMatch) return;
+            let xExpr = commaMatch[1].trim(), yExpr = commaMatch[2].trim();
+            if (shouldRound) {
+              xExpr = xExpr.replace(/(\d+\.\d{4,})/g, (m) => roundToThreeDecimals(parseFloat(m)).toString());
+              yExpr = yExpr.replace(/(\d+\.\d{4,})/g, (m) => roundToThreeDecimals(parseFloat(m)).toString());
+            }
+            xExpr = xExpr.replace(/t\*\*\((\d+)\)/g, "\\t^$1");
+            xExpr = xExpr.replace(/\(1-t\)\*\*\((\d+)\)/g, "(1-\\t)^$1");
+            yExpr = yExpr.replace(/t\*\*\((\d+)\)/g, "\\t^$1");
+            yExpr = yExpr.replace(/\(1-t\)\*\*\((\d+)\)/g, "(1-\\t)^$1");
+            xExpr = xExpr.replace(/([ (+\-*/,])t(?!\w)/g, "$1\\t");
+            yExpr = yExpr.replace(/([ (+\-*/,])t(?!\w)/g, "$1\\t");
+            xExpr = xExpr.replace(/^t(?!\w)/, "\\t");
+            yExpr = yExpr.replace(/^t(?!\w)/, "\\t");
+            const lineStyle = convertLineStyle(options);
+            plots.push({ original: match[0], options, xExpression: xExpr, yExpression: yExpr, lineStyle });
+          });
+          return { hasParametricPlots: plots.length > 0, plots };
+        } catch (error) {
+          return { hasParametricPlots: false, plots: [] };
+        }
+      }
+      function cleanTikZCode(code, opts = {}) {
+        code = code.replace(/\\draw\s+\[/g, "\\\\draw[");
+        const shouldRound = opts.round !== false;
+        const includePoints = opts.points !== false;
+        const includeLabels = opts.labels !== false;
+        const tikzMatch = code.match(/\\begin\{tikzpicture\}([\s\S]*?)\\end\{tikzpicture\}/);
+        if (!tikzMatch) throw new Error("\u672A\u627E\u5230 tikzpicture \u73AF\u5883");
+        const pointRegex = /\\draw\s*\[fill=[^\]]+\]\s*\(([^)]+)\)\s*circle\s*\(([^)]+)\);/g;
+        const nodeRegex = /\\draw\[color=[^\]]+\]\s*\([^)]+\)\s*node\s*\{\$(?!.*\\textrm\{\\degre\})([^$]+(?:\{[^}]*\})?[^$]*)\$\}/g;
+        const pointMap = /* @__PURE__ */ new Map();
+        const pointMatches = [...code.matchAll(pointRegex)];
+        const nodeMatches = [...code.matchAll(nodeRegex)];
+        const anchoredNodes = [...code.matchAll(/\\draw\s*(?:\[[^\]]*\])?\s*\(([^)]+)\)\s*node\s*\[([^\]]+)\]\s*\{([^\r\n]*)\};/g)];
+        const usedAnchoredNodes = /* @__PURE__ */ new Set();
+        const allPoints = [];
+        pointMatches.forEach((match) => {
+          const coords = match[1];
+          const formattedCoords = formatCoordinate(`(${coords})`, shouldRound);
+          allPoints.push({ original: coords, formatted: formattedCoords.slice(1, -1) });
+        });
+        allPoints.forEach((point, index) => {
+          const [x, y] = point.original.split(",").map(Number);
+          const candidates = anchoredNodes.map((node, i) => {
+            const label = node[3].match(/^\$\\mathit\{([A-Za-z][A-Za-z0-9_]*)\}\$$/)?.[1] || node[3].match(/^\$([A-Za-z][A-Za-z0-9_]*)\$$/)?.[1];
+            const [nx, ny] = node[1].split(",").map(Number);
+            return { i, label, distance: Math.hypot(nx - x, ny - y) };
+          }).filter((n) => n.label && !usedAnchoredNodes.has(n.i)).sort((a, b) => a.distance - b.distance);
+          if (candidates.length && candidates[0].distance < 1) {
+            pointMap.set(candidates[0].label, point.formatted);
+            usedAnchoredNodes.add(candidates[0].i);
+          } else if (index < nodeMatches.length) {
+            pointMap.set(nodeMatches[index][1], point.formatted);
+          } else {
+            pointMap.set(`gikzPoint${index}`, point.formatted);
+          }
+        });
+        const functionPlotsResult = extractFunctionPlots(code, shouldRound);
+        const parametricPlotResult = extractParametricPlots(code, shouldRound);
+        const textLabels = anchoredNodes.filter((_, i) => !usedAnchoredNodes.has(i)).map((match) => ({
+          coords: formatCoordinate(`(${match[1]})`, shouldRound),
+          options: match[2],
+          content: match[3]
+        }));
+        const angleLabelRegex = /\\draw\[color=([^\]]+)\]\s*\(([^)]+)\)\s*node\s*\{\$([^}]+)\\textrm\{\\degre\}\$\};/g;
+        const angleLabelMatches = [...code.matchAll(angleLabelRegex)];
+        const angleLabels = [];
+        angleLabelMatches.forEach((match) => {
+          angleLabels.push({
+            color: match[1],
+            coords: formatCoordinate(`(${match[2]})`, shouldRound),
+            content: match[3]
+          });
+        });
+        const lineRegex = /\\draw\s*(\[[^\]]+\])?\s*\(([^)]+)\)\s*--\s*\(([^)]+)\);/g;
+        const lineMatches = [...code.matchAll(lineRegex)];
+        const circleRegex = /\\draw\s*\[([^\]]*line[^\]]*)\]\s*\(([^)]+)\)\s*circle\s*\(([^)]+)\);/g;
+        const circleMatches = [...code.matchAll(circleRegex)];
+        const circles = [];
+        circleMatches.forEach((match) => {
+          const options = match[1];
+          const centerCoords = match[2];
+          const radius = match[3];
+          const formattedCenter = formatCoordinate(`(${centerCoords})`, shouldRound);
+          const lineStyle = convertLineStyle(options);
+          let centerLabel = null;
+          for (const [label, coords] of pointMap) {
+            const coordStr = coords.includes("(") ? coords : `(${coords})`;
+            if (coordStr.includes(centerCoords.trim()) || formattedCenter.includes(coords)) {
+              centerLabel = label;
+              break;
+            }
+          }
+          circles.push({
+            center: centerLabel ? `(${centerLabel})` : formattedCenter,
+            radius: shouldRound ? roundToThreeDecimals(parseFloat(radius)) + (radius.includes("cm") ? "cm" : "") : radius,
+            lineStyle
+          });
+        });
+        const arcRegex = /\\draw\s*(\[[^\]]*\])?\s*plot\[domain=([^:]+):([^,]+),variable=\\t\]\(\{1\*([^\*]+)\*cos\(\\t r\)\+0\*[^\*]+\*sin\(\\t r\)\},\{0\*[^\*]+\*cos\(\\t r\)\+1\*[^\*]+\*sin\(\\t r\)\}\);/g;
+        const arcMatches = [...code.matchAll(arcRegex)];
+        const arcs = [];
+        arcMatches.forEach((match) => {
+          const style = match[1] || "";
+          const rv = (val) => shouldRound ? roundToThreeDecimals(parseFloat(val)) : val;
+          let lineStyle = "";
+          if (style.includes("dash pattern=on 1pt off 1pt on 1pt off 4pt")) lineStyle = "dash dot";
+          else if (style.includes("dash pattern=on 1pt off 1pt")) lineStyle = "dashed";
+          else if (style.includes("dotted")) lineStyle = "dotted";
+          const shiftRegex = /shift=\{\(([^,]+),([^)]+)\)\}/;
+          const shiftMatch = style.match(shiftRegex);
+          let styleParts = [];
+          if (lineStyle) styleParts.push(lineStyle);
+          if (shiftMatch) styleParts.push(`shift={(${rv(shiftMatch[1])},${rv(shiftMatch[2])})}`);
+          styleParts.push("smooth");
+          let newStyle = styleParts.length > 0 ? "[" + styleParts.join(", ") + "]" : "";
+          arcs.push({ style: newStyle, startAngle: rv(match[2]), endAngle: rv(match[3]), radius: rv(match[4]) });
+        });
+        const sectorRegex = /\\draw\s*\[shift=\{\(([^,]+),([^)]+)\)\}[^\]]*\]\s*\(0,0\)\s*--\s*plot\[domain=([^:]+):([^,\]]+),variable=\\t\]\(\{1\*([^\*]+)\*cos\(\\t r\)\+0\*[^\*]+\*sin\(\\t r\)\},\{0\*[^\*]+\*cos\(\\t r\)\+1\*[^\*]+\*sin\(\\t r\)\}\)\s*--\s*cycle\s*;/g;
+        const sectorMatches = [...code.matchAll(sectorRegex)];
+        const sectors = [];
+        sectorMatches.forEach((match) => {
+          const rv = (val) => shouldRound ? roundToThreeDecimals(parseFloat(val)) : val;
+          const style = match[0].match(/\\draw\s*\[([^\]]+)\]/)[1];
+          sectors.push({
+            shiftX: rv(match[1].trim()),
+            shiftY: rv(match[2].trim()),
+            startAngle: rv(match[3].trim()),
+            endAngle: rv(match[4].trim()),
+            radius: rv(match[5].trim()),
+            lineStyle: convertLineStyle(style)
+          });
+        });
+        const ellipseRegex = /\\draw\s*\[([^\]]*)\]\s*\(([^)]+)\)\s*ellipse\s*\(([^)]+)\);/g;
+        const ellipseMatches = [...code.matchAll(ellipseRegex)];
+        const ellipses = [];
+        ellipseMatches.forEach((match) => {
+          const options = match[1], centerCoords = match[2], radii = match[3];
+          const radiusParts = radii.split(" and ");
+          let xR = radiusParts[0]?.trim() || "", yR = radiusParts[1]?.trim() || "";
+          const formattedCenter = formatCoordinate(`(${centerCoords})`, shouldRound);
+          let centerLabel = null;
+          for (const [label, coords] of pointMap) {
+            const cs = coords.includes("(") ? coords : `(${coords})`;
+            if (cs.includes(centerCoords.trim()) || formattedCenter.includes(coords)) {
+              centerLabel = label;
+              break;
+            }
+          }
+          let rotationAngle = 0, rotationCenter = null;
+          const rotateMatch = options.match(/rotate around=\{([^:]+):\(([^)]+)\)\}/);
+          if (rotateMatch) {
+            rotationAngle = parseFloat(rotateMatch[1]);
+            if (shouldRound) rotationAngle = roundToThreeDecimals(rotationAngle);
+            const rc = rotateMatch[2];
+            const frc = formatCoordinate(`(${rc})`, shouldRound);
+            for (const [label, coords] of pointMap) {
+              const cs = coords.includes("(") ? coords : `(${coords})`;
+              if (cs.includes(rc.trim()) || frc.includes(coords)) {
+                rotationCenter = label;
+                break;
+              }
+            }
+            if (!rotationCenter) rotationCenter = frc;
+          }
+          const lineStyle = convertLineStyle(options);
+          if (shouldRound && xR && yR) {
+            const xU = xR.replace(/[0-9.\-\s]/g, ""), yU = yR.replace(/[0-9.\-\s]/g, "");
+            xR = roundToThreeDecimals(parseFloat(xR)) + xU;
+            yR = roundToThreeDecimals(parseFloat(yR)) + yU;
+          }
+          const obj = { center: centerLabel ? `(${centerLabel})` : formattedCenter, xRadius: xR, yRadius: yR, lineStyle, hasRotation: !!rotateMatch };
+          if (rotateMatch) {
+            obj.rotationAngle = rotationAngle;
+            obj.rotationCenter = rotationCenter ? `(${rotationCenter})` : formattedCenter;
+          }
+          ellipses.push(obj);
+        });
+        const angleRegex = /\\draw\s*\[shift=\{\(([^,]+),([^)]+)\)\}[^\]]*\]\s*\(0,0\)\s*--\s*\(([^:]+):([^)]+)\)\s*arc\s*\(([^:]+):([^)]+):([^)]+)\)\s*--\s*cycle;/g;
+        const angleMatches = [...code.matchAll(angleRegex)];
+        const angles = [];
+        angleMatches.forEach((match) => {
+          const cX = match[1].trim(), cY = match[2].trim();
+          const formattedCenter = formatCoordinate(`(${cX},${cY})`, shouldRound);
+          let centerLabel = null;
+          for (const [label, coords] of pointMap) {
+            const cs = coords.includes("(") ? coords : `(${coords})`;
+            if (cs.includes(`${cX},${cY}`) || formattedCenter.includes(coords)) {
+              centerLabel = label;
+              break;
+            }
+          }
+          const rv = (v) => shouldRound ? roundToThreeDecimals(parseFloat(v)) : v;
+          angles.push({
+            center: centerLabel ? `(${centerLabel})` : formattedCenter,
+            startAngle: rv(match[3].trim()),
+            endAngle: rv(match[6].trim()),
+            radius: rv(match[4].trim())
+          });
+        });
+        let result = "\\begin{tikzpicture}[scale=1]\n";
+        if (pointMap.size > 0) {
+          result += "  % \u5750\u6807\u70B9\u5B9A\u4E49\n";
+          for (const [label, coords] of pointMap) {
+            result += `  \\coordinate (${label}) at ${coords.includes("(") ? coords : `(${coords})`};
+`;
+          }
+          result += "\n";
+        }
+        if (functionPlotsResult.hasFunctions) {
+          result += "  % \u51FD\u6570\u56FE\u50CF\n" + functionPlotsResult.scopeCode + "\n";
+        }
+        if (parametricPlotResult.hasParametricPlots) {
+          result += "  % \u8D1D\u585E\u5C14\u66F2\u7EBF\n";
+          parametricPlotResult.plots.forEach((plot) => {
+            const ls = plot.lineStyle ? `[${plot.lineStyle}, smooth, samples=100, domain=0:1, variable=\\t]` : "[smooth, samples=100, domain=0:1, variable=\\t]";
+            result += `  \\draw${ls} plot
+    ({${plot.xExpression}},
+     {${plot.yExpression}});
+
+`;
+          });
+        }
+        if (lineMatches.length > 0 || circles.length > 0 || arcs.length > 0 || ellipses.length > 0 || angles.length > 0 || angleLabels.length > 0 || sectors.length > 0) {
+          result += "  % \u51E0\u4F55\u5143\u7D20\n";
+          if (angles.length > 0) {
+            result += "  % \u89D2\u5EA6\n";
+            angles.forEach((a) => {
+              result += `  \\fill [shift=${a.center}, gray!30] (0,0) -- (${a.startAngle}:${a.radius}) arc (${a.startAngle}:${a.endAngle}:${a.radius}) -- cycle;
+`;
+            });
+            result += "\n";
+          }
+          if (sectors.length > 0) {
+            result += "  % \u6247\u5F62\u7ED8\u5236\n";
+            sectors.forEach((s) => {
+              const st = s.lineStyle ? `[${s.lineStyle}]` : "";
+              result += `  \\draw${st} [shift={(${s.shiftX},${s.shiftY})}] (0,0) -- plot[domain=${s.startAngle}:${s.endAngle}]({1*${s.radius}*cos(\\x r)+0*${s.radius}*sin(\\x r)},{0*${s.radius}*cos(\\x r)+1*${s.radius}*sin(\\x r)}) -- cycle;
+`;
+            });
+            if (lineMatches.length > 0) result += "\n";
+          }
+          if (circles.length > 0) {
+            circles.forEach((c) => {
+              result += c.lineStyle ? `  \\draw[${c.lineStyle}] ${c.center} circle (${c.radius});
+` : `  \\draw ${c.center} circle (${c.radius});
+`;
+            });
+            if (lineMatches.length > 0 || arcs.length > 0) result += "\n";
+          }
+          if (ellipses.length > 0) {
+            result += "  % \u692D\u5706\n";
+            ellipses.forEach((e) => {
+              const drawOpts = [];
+              if (e.lineStyle) drawOpts.push(e.lineStyle);
+              if (e.hasRotation) drawOpts.push(`rotate around={${e.rotationAngle}:${e.rotationCenter}}`);
+              result += drawOpts.length > 0 ? `  \\draw[${drawOpts.join(", ")}] ${e.center} ellipse (${e.xRadius} and ${e.yRadius});
+` : `  \\draw ${e.center} ellipse (${e.xRadius} and ${e.yRadius});
+`;
+            });
+            if (lineMatches.length > 0 || arcs.length > 0) result += "\n";
+          }
+          if (arcs.length > 0) {
+            result += "  % \u5706\u5F27\u7ED8\u5236\n";
+            arcs.forEach((arc) => {
+              const s = arc.style.trim() ? arc.style : "";
+              result += `  \\draw${s} plot[domain=${arc.startAngle}:${arc.endAngle}]({1*${arc.radius}*cos(\\x r)+0*${arc.radius}*sin(\\x r)},{0*${arc.radius}*cos(\\x r)+1*${arc.radius}*sin(\\x r)});
+`;
+            });
+            if (lineMatches.length > 0) result += "\n";
+          }
+          const processedLines = /* @__PURE__ */ new Set();
+          const parseCoords = (str) => {
+            const m = str.match(/\(([^,]+),([^)]+)\)/);
+            return m ? { x: parseFloat(m[1]), y: parseFloat(m[2]) } : null;
+          };
+          lineMatches.forEach((match) => {
+            const style = match[1] || "";
+            const coord1 = match[2], coord2 = match[3];
+            const convertedStyle = convertLineStyle(style);
+            let label1 = null, label2 = null;
+            const tc1 = formatCoordinate(`(${coord1})`, shouldRound);
+            const tc2 = formatCoordinate(`(${coord2})`, shouldRound);
+            const t1 = parseCoords(tc1), t2 = parseCoords(tc2);
+            for (const [label, coords] of pointMap) {
+              const pcs = coords.includes("(") ? coords : `(${coords})`;
+              const p = parseCoords(pcs);
+              if (p && t1 && Math.abs(p.x - t1.x) < 1e-3 && Math.abs(p.y - t1.y) < 1e-3) label1 = label;
+              if (p && t2 && Math.abs(p.x - t2.x) < 1e-3 && Math.abs(p.y - t2.y) < 1e-3) label2 = label;
+            }
+            if (label1 && label2) {
+              const key = `${label1}-${label2}`, rev = `${label2}-${label1}`;
+              if (!processedLines.has(key) && !processedLines.has(rev)) {
+                result += convertedStyle ? `  \\draw[${convertedStyle}] (${label1}) -- (${label2});
+` : `  \\draw (${label1}) -- (${label2});
+`;
+                processedLines.add(key);
+              }
+            } else {
+              const fc1 = formatCoordinate(`(${coord1})`, shouldRound);
+              const fc2 = formatCoordinate(`(${coord2})`, shouldRound);
+              result += convertedStyle ? `  \\draw[${convertedStyle}] ${fc1} -- ${fc2};
+` : `  \\draw ${fc1} -- ${fc2};
+`;
+            }
+          });
+        }
+        if (includePoints && pointMap.size > 0) {
+          result += "\n  % \u70B9\u6807\u8BB0\n";
+          for (const [label] of pointMap) {
+            result += `  \\draw[fill=black] (${label}) circle (1pt);
+`;
+          }
+        }
+        if (includeLabels && pointMap.size > 0) {
+          result += "\n  % \u70B9\u6807\u7B7E\n";
+          const allPointsData = [];
+          for (const [label, coords] of pointMap) {
+            const m = coords.match(/\(?([^,]+),([^)]+)\)?/);
+            if (m) allPointsData.push({ label, x: parseFloat(m[1]), y: parseFloat(m[2]) });
+          }
+          for (const point of allPointsData) {
+            if (/^gikzPoint\d+$/.test(point.label)) continue;
+            const pos = getSmartLabelPosition(point.x, point.y, allPointsData);
+            result += `  \\node [${pos}] at (${point.label}) {$${point.label}$};
+`;
+          }
+        }
+        if (angleLabels.length > 0) {
+          result += "\n  % \u89D2\u5EA6\u6807\u7B7E\n";
+          angleLabels.forEach((l) => {
+            result += `  \\draw ${l.coords} node {$${l.content}^{\\circ}$};
+`;
+          });
+        }
+        if (textLabels.length > 0) {
+          result += "\n  % \u6587\u672C\u6807\u7B7E\n";
+          textLabels.forEach((l) => {
+            result += `  \\draw ${l.coords} node[${l.options}] {${l.content}};
+`;
+          });
+        }
+        result += "\\end{tikzpicture}";
+        return result;
+      }
+      function convertGeoGebraXML(xmlStr, opts = {}) {
+        const shouldRound = opts.round !== false;
+        const includePoints = opts.points !== false;
+        const includeLabels = opts.labels !== false;
+        const rv = (v) => shouldRound ? roundToThreeDecimals(v) : v;
+        const de = (s) => s.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&apos;/g, "'").replace(/&quot;/g, '"');
+        const constrM = xmlStr.match(/<construction[^>]*>([\s\S]*?)<\/construction>/);
+        if (!constrM) throw new Error("XML \u4E2D\u672A\u627E\u5230 construction \u5757");
+        const constr = constrM[1];
+        const elements = /* @__PURE__ */ new Map();
+        const elRe = /<element\s+type="([^"]+)"\s+label="([^"]+)">([\s\S]*?)<\/element>/g;
+        let m;
+        while (m = elRe.exec(constr)) {
+          const label = de(m[2]), body = m[3];
+          const el = { type: m[1], label };
+          const showM = body.match(/<show\s+object="([^"]+)"\s+label="([^"]+)"/);
+          el.visible = showM ? showM[1] === "true" : false;
+          el.showLabel = showM ? showM[2] === "true" : false;
+          const coordsM = body.match(/<coords\s+x="([^"]+)"\s+y="([^"]+)"\s+z="([^"]+)"/);
+          if (coordsM) {
+            const z = parseFloat(coordsM[3]) || 1;
+            el.x = parseFloat(coordsM[1]) / z;
+            el.y = parseFloat(coordsM[2]) / z;
+          }
+          const valM = body.match(/<value\s+val="([^"]+)"/);
+          if (valM) el.value = parseFloat(valM[1]);
+          const arcM = body.match(/<arcSize\s+val="([^"]+)"/);
+          if (arcM) el.arcSize = parseInt(arcM[1]);
+          const colM = body.match(/<objColor[^>]+alpha="([^"]+)"/);
+          if (colM) el.alpha = parseFloat(colM[1]);
+          const lineM = body.match(/<lineStyle\s+thickness="([^"]+)"\s+type="([^"]+)"/);
+          if (lineM) {
+            el.lineThickness = parseInt(lineM[1]);
+            el.lineType = parseInt(lineM[2]);
+          }
+          if (el.x !== void 0 && (isNaN(el.x) || isNaN(el.y))) continue;
+          elements.set(label, el);
+        }
+        const commands = [];
+        const cmdRe = /<command\s+name="([^"]+)">([\s\S]*?)<\/command>/g;
+        while (m = cmdRe.exec(constr)) {
+          const cmd = { name: m[1], inputs: [], outputs: [] };
+          const inM = m[2].match(/<input\s+([^/]*)\/>/);
+          if (inM) {
+            const r = /a(\d+)="([^"]+)"/g;
+            let a;
+            while (a = r.exec(inM[1])) cmd.inputs[+a[1]] = de(a[2]);
+          }
+          const outM = m[2].match(/<output\s+([^/]*)\/>/);
+          if (outM) {
+            const r = /a(\d+)="([^"]+)"/g;
+            let a;
+            while (a = r.exec(outM[1])) cmd.outputs[+a[1]] = de(a[2]);
+          }
+          commands.push(cmd);
+        }
+        const cmdByOut = /* @__PURE__ */ new Map();
+        for (const cmd of commands)
+          for (const lbl of cmd.outputs) if (lbl) cmdByOut.set(lbl, cmd);
+        const polyEdges = /* @__PURE__ */ new Set();
+        for (const cmd of commands) {
+          if (cmd.name === "Polygon") {
+            for (let i = 1; i < cmd.outputs.length; i++) if (cmd.outputs[i]) polyEdges.add(cmd.outputs[i]);
+          }
+        }
+        const refPts = /* @__PURE__ */ new Set();
+        const lsName = (t) => {
+          switch (t) {
+            case 10:
+            case 15:
+              return "dashed";
+            case 20:
+              return "dotted";
+            case 30:
+              return "dash dot";
+            default:
+              return "";
+          }
+        };
+        const segs = [];
+        for (const [label, el] of elements) {
+          if (!el.visible || el.type !== "segment" || polyEdges.has(label)) continue;
+          const cmd = cmdByOut.get(label);
+          if (cmd && cmd.name === "Segment" && cmd.inputs[0] && cmd.inputs[1]) {
+            segs.push({ from: cmd.inputs[0], to: cmd.inputs[1], ls: lsName(el.lineType || 0) });
+            refPts.add(cmd.inputs[0]);
+            refPts.add(cmd.inputs[1]);
+          }
+        }
+        const circs = [];
+        for (const [label, el] of elements) {
+          if (!el.visible || el.type !== "conic") continue;
+          const cmd = cmdByOut.get(label);
+          if (cmd && cmd.name === "Circle") {
+            const cEl = elements.get(cmd.inputs[0]), tEl = elements.get(cmd.inputs[1]);
+            if (cEl && tEl && cEl.x !== void 0 && tEl.x !== void 0) {
+              const dx = tEl.x - cEl.x, dy = tEl.y - cEl.y;
+              circs.push({ center: cmd.inputs[0], radius: rv(Math.sqrt(dx * dx + dy * dy)) });
+              refPts.add(cmd.inputs[0]);
+            }
+          }
+        }
+        const polys = [];
+        for (const [label, el] of elements) {
+          if (!el.visible || el.type !== "polygon") continue;
+          const cmd = cmdByOut.get(label);
+          if (cmd && cmd.name === "Polygon") {
+            const verts = [];
+            for (let i = 0; cmd.inputs[i]; i++) {
+              verts.push(cmd.inputs[i]);
+              refPts.add(cmd.inputs[i]);
+            }
+            polys.push({ vertices: verts, alpha: el.alpha || 0 });
+          }
+        }
+        const angs = [];
+        for (const [label, el] of elements) {
+          if (!el.visible || el.type !== "angle") continue;
+          const cmd = cmdByOut.get(label);
+          if (cmd && cmd.name === "Angle") {
+            angs.push({ ptA: cmd.inputs[0], vertex: cmd.inputs[1], ptC: cmd.inputs[2], value: el.value });
+            refPts.add(cmd.inputs[0]);
+            refPts.add(cmd.inputs[1]);
+            refPts.add(cmd.inputs[2]);
+          }
+        }
+        for (const [label, el] of elements)
+          if (el.type === "point" && (el.visible || el.showLabel)) refPts.add(label);
+        const coords = [];
+        for (const label of refPts) {
+          const el = elements.get(label);
+          if (el && el.type === "point" && el.x !== void 0) coords.push({ label, x: rv(el.x), y: rv(el.y) });
+        }
+        coords.sort((a, b) => a.label.localeCompare(b.label));
+        let out = "\\begin{tikzpicture}[scale=1]\n";
+        if (coords.length > 0) {
+          out += "  % \u5750\u6807\u70B9\u5B9A\u4E49\n";
+          for (const c of coords) out += `  \\coordinate (${c.label}) at (${c.x},${c.y});
+`;
+          out += "\n";
+        }
+        out += "  % \u51E0\u4F55\u5143\u7D20\n";
+        if (angs.length > 0) {
+          for (const ang of angs) {
+            const vEl = elements.get(ang.vertex), aEl = elements.get(ang.ptA), cEl = elements.get(ang.ptC);
+            if (!vEl || !aEl || !cEl) continue;
+            let sa = rv(Math.atan2(aEl.y - vEl.y, aEl.x - vEl.x) * 180 / Math.PI);
+            let ea = rv(Math.atan2(cEl.y - vEl.y, cEl.x - vEl.x) * 180 / Math.PI);
+            if (ea <= sa) ea += 360;
+            out += `  \\fill[green!10] (${ang.vertex}) -- ++(${sa}:0.4) arc (${sa}:${ea}:0.4) -- cycle;
+`;
+          }
+          out += "\n";
+        }
+        if (polys.length > 0) {
+          for (const p of polys) {
+            if (p.alpha > 0) {
+              const pth = p.vertices.map((v) => `(${v})`).join(" -- ") + " -- cycle";
+              out += `  \\fill[gray!20, fill opacity=${rv(p.alpha)}] ${pth};
+`;
+            }
+          }
+          out += "\n";
+        }
+        if (circs.length > 0) {
+          for (const c of circs) out += `  \\draw (${c.center}) circle (${c.radius});
+`;
+          out += "\n";
+        }
+        if (segs.length > 0) {
+          const drawn = /* @__PURE__ */ new Set();
+          for (const s of segs) {
+            const k = [s.from, s.to].sort().join("|");
+            if (drawn.has(k)) continue;
+            drawn.add(k);
+            out += s.ls ? `  \\draw[${s.ls}] (${s.from}) -- (${s.to});
+` : `  \\draw (${s.from}) -- (${s.to});
+`;
+          }
+          out += "\n";
+        }
+        if (includePoints) {
+          const visPts = coords.filter((c) => {
+            const e = elements.get(c.label);
+            return e && e.visible;
+          });
+          if (visPts.length > 0) {
+            out += "  % \u70B9\u6807\u8BB0\n";
+            for (const p of visPts) out += `  \\draw[fill=black] (${p.label}) circle (1pt);
+`;
+            out += "\n";
+          }
+        }
+        if (includeLabels) {
+          const lblPts = coords.filter((c) => {
+            const e = elements.get(c.label);
+            return e && (e.visible || e.showLabel);
+          });
+          if (lblPts.length > 0) {
+            out += "  % \u70B9\u6807\u7B7E\n";
+            for (const p of lblPts) {
+              const pos = getSmartLabelPosition(p.x, p.y, coords);
+              out += `  \\node[${pos}] at (${p.label}) {$${p.label}$};
+`;
+            }
+          }
+        }
+        out += "\\end{tikzpicture}";
+        return out;
+      }
+      function wrapStandalone(tikzCode) {
+        return `\\documentclass[border=5pt]{standalone}
+\\usepackage{tikz}
+\\usepackage{pgfplots}
+\\pgfplotsset{compat=1.15}
+\\usetikzlibrary{arrows.meta}
+
+\\begin{document}
+${tikzCode}
+\\end{document}
+`;
+      }
+      module.exports = { cleanTikZCode, wrapStandalone, convertGeoGebraXML };
+    }
+  });
+
+  // gikz/browser.cjs
+  var require_browser = __commonJS({
+    "gikz/browser.cjs"() {
+      globalThis.Gikz = Object.freeze(require_core());
+    }
+  });
+  require_browser();
+})();