npm - @nice2dev/ui-math - Versions diffs - 1.2.1 → 1.2.2 - Mend

@nice2dev/ui-math 1.2.1 → 1.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.mjs CHANGED Viewed

@@ -1,11 +1,11 @@
-var pe = Object.defineProperty;
-var ue = (e, t, r) => t in e ? pe(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var T = (e, t, r) => ue(e, typeof t != "symbol" ? t + "" : t, r);
+var me = Object.defineProperty;
+var ue = (e, t, r) => t in e ? me(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var z = (e, t, r) => ue(e, typeof t != "symbol" ? t + "" : t, r);
 import { jsx as d, jsxs as v, Fragment as oe } from "react/jsx-runtime";
-import { NiceAppShell as ge, NiceIcon as X } from "@nice2dev/ui";
-import { NiceTutorialButton as xe, resolveTutorial as me, resolveCssColor as I, NiceIcon as G } from "@nice2dev/ui-core";
-import ye, { useMemo as he, useContext as j, createContext as F, useState as P, useRef as U, useCallback as R, useEffect as V } from "react";
-const J = {
+import { NiceAppShell as ye, NiceIcon as N } from "@nice2dev/ui";
+import { useNiceTranslation as xe, NiceTutorialButton as he, resolveTutorial as fe, resolveCssColor as D, NiceIcon as j } from "@nice2dev/ui-core";
+import be, { useMemo as ae, useContext as F, createContext as O, useState as M, useRef as U, useCallback as R, useEffect as Y } from "react";
+const K = {
   en: {
     "calculator.matrixA": "Matrix A",
     "calculator.matrixB": "Matrix B",
@@ -26,7 +26,44 @@ const J = {
     "editor.handwritingNote": "Draw your equation above. Handwriting recognition requires external API integration.",
     "editor.templates": "Templates",
     "editor.copyLatex": "Copy LaTeX",
-    "plotter.close": "Close"
+    "plotter.close": "Close",
+    "calculator.standard": "Standard",
+    "calculator.scientific": "Scientific",
+    "calculator.programmer": "Programmer",
+    "calculator.matrix": "Matrix",
+    "calculator.calculus": "Calculus",
+    "calculator.units": "Units",
+    "geometry.select": "Select",
+    "geometry.point": "Point",
+    "geometry.segment": "Segment",
+    "geometry.line": "Line",
+    "geometry.ray": "Ray",
+    "geometry.circle": "Circle",
+    "geometry.polygon": "Polygon",
+    "geometry.perpendicular": "Perpendicular",
+    "geometry.parallel": "Parallel",
+    "geometry.midpoint": "Midpoint",
+    "geometry.angleBisector": "Angle Bisector",
+    "geometry.intersection": "Intersection",
+    "geometry.reflect": "Reflect",
+    "geometry.rotate": "Rotate",
+    "geometry.measure": "Measure",
+    "geometry.arc": "Arc",
+    "geometry.angle": "Angle",
+    "geometry.tangent": "Tangent",
+    "geometry.translate": "Translate",
+    "geometry.dilate": "Dilate",
+    "geometry.text": "Text",
+    "geometry.tool": "Tool: {tool}",
+    "geometry.objects": "Objects: {elements}",
+    "geometry.points": "Points: {pointCount}",
+    "geometry.scaleX": "Scale: {scale}x",
+    "plotter.parametricXTYT": "Parametric (x(t), y(t))",
+    "plotter.polarRF": "Polar r = f(θ)",
+    "plotter.n3dSurfaceZFX": "3D Surface z = f(x,y)",
+    "plotter.expression": "Expression...",
+    "plotter.addPlot": "+ Add Plot",
+    "editor.previewRequiresKatexMathjaxIntegration": "Preview (requires KaTeX/MathJax integration):"
   },
   pl: {
     "calculator.matrixA": "Macierz A",
@@ -48,7 +85,44 @@ const J = {
     "editor.handwritingNote": "Narysuj równanie powyżej. Rozpoznawanie pisma wymaga zewnętrznej integracji API.",
     "editor.templates": "Szablony",
     "editor.copyLatex": "Kopiuj LaTeX",
-    "plotter.close": "Zamknij"
+    "plotter.close": "Zamknij",
+    "calculator.standard": "Standardowy",
+    "calculator.scientific": "Naukowy",
+    "calculator.programmer": "Programisty",
+    "calculator.matrix": "Macierze",
+    "calculator.calculus": "Analiza",
+    "calculator.units": "Jednostki",
+    "geometry.select": "Zaznacz",
+    "geometry.point": "Punkt",
+    "geometry.segment": "Odcinek",
+    "geometry.line": "Prosta",
+    "geometry.ray": "Półprosta",
+    "geometry.circle": "Okrąg",
+    "geometry.polygon": "Wielokąt",
+    "geometry.perpendicular": "Prostopadła",
+    "geometry.parallel": "Równoległa",
+    "geometry.midpoint": "Środek odcinka",
+    "geometry.angleBisector": "Dwusieczna kąta",
+    "geometry.intersection": "Przecięcie",
+    "geometry.reflect": "Odbicie",
+    "geometry.rotate": "Obrót",
+    "geometry.measure": "Pomiar",
+    "geometry.arc": "Łuk",
+    "geometry.angle": "Kąt",
+    "geometry.tangent": "Styczna",
+    "geometry.translate": "Przesunięcie",
+    "geometry.dilate": "Jednokładność",
+    "geometry.text": "Tekst",
+    "geometry.tool": "Narzędzie: {tool}",
+    "geometry.objects": "Obiekty: {elements}",
+    "geometry.points": "Punkty: {pointCount}",
+    "geometry.scaleX": "Skala: {scale}x",
+    "plotter.parametricXTYT": "Parametryczny (x(t), y(t))",
+    "plotter.polarRF": "Biegunowy r = f(θ)",
+    "plotter.n3dSurfaceZFX": "Powierzchnia 3D z = f(x,y)",
+    "plotter.expression": "Wyrażenie...",
+    "plotter.addPlot": "+ Dodaj wykres",
+    "editor.previewRequiresKatexMathjaxIntegration": "Podgląd (wymaga integracji KaTeX/MathJax):"
   },
   de: {
     "calculator.matrixA": "Matrix A",
@@ -70,7 +144,44 @@ const J = {
     "editor.handwritingNote": "Zeichnen Sie Ihre Gleichung oben. Die Handschrifterkennung erfordert eine externe API-Integration.",
     "editor.templates": "Vorlagen",
     "editor.copyLatex": "LaTeX kopieren",
-    "plotter.close": "Schließen"
+    "plotter.close": "Schließen",
+    "calculator.standard": "Standard",
+    "calculator.scientific": "Wissenschaftlich",
+    "calculator.programmer": "Programmierer",
+    "calculator.matrix": "Matrix",
+    "calculator.calculus": "Analysis",
+    "calculator.units": "Einheiten",
+    "geometry.select": "Auswählen",
+    "geometry.point": "Punkt",
+    "geometry.segment": "Strecke",
+    "geometry.line": "Gerade",
+    "geometry.ray": "Strahl",
+    "geometry.circle": "Kreis",
+    "geometry.polygon": "Polygon",
+    "geometry.perpendicular": "Senkrechte",
+    "geometry.parallel": "Parallele",
+    "geometry.midpoint": "Mittelpunkt",
+    "geometry.angleBisector": "Winkelhalbierende",
+    "geometry.intersection": "Schnittpunkt",
+    "geometry.reflect": "Spiegeln",
+    "geometry.rotate": "Drehen",
+    "geometry.measure": "Messen",
+    "geometry.arc": "Bogen",
+    "geometry.angle": "Winkel",
+    "geometry.tangent": "Tangente",
+    "geometry.translate": "Verschieben",
+    "geometry.dilate": "Strecken",
+    "geometry.text": "Text",
+    "geometry.tool": "Werkzeug: {tool}",
+    "geometry.objects": "Objekte: {elements}",
+    "geometry.points": "Punkte: {pointCount}",
+    "geometry.scaleX": "Maßstab: {scale}x",
+    "plotter.parametricXTYT": "Parametrisch (x(t), y(t))",
+    "plotter.polarRF": "Polar r = f(θ)",
+    "plotter.n3dSurfaceZFX": "3D-Fläche z = f(x,y)",
+    "plotter.expression": "Ausdruck...",
+    "plotter.addPlot": "+ Diagramm hinzufügen",
+    "editor.previewRequiresKatexMathjaxIntegration": "Vorschau (erfordert KaTeX/MathJax-Integration):"
   },
   fr: {
     "calculator.matrixA": "Matrice A",
@@ -92,7 +203,44 @@ const J = {
     "editor.handwritingNote": "Dessinez votre équation ci-dessus. La reconnaissance d'écriture nécessite une intégration API externe.",
     "editor.templates": "Modèles",
     "editor.copyLatex": "Copier le LaTeX",
-    "plotter.close": "Fermer"
+    "plotter.close": "Fermer",
+    "calculator.standard": "Standard",
+    "calculator.scientific": "Scientifique",
+    "calculator.programmer": "Programmeur",
+    "calculator.matrix": "Matrice",
+    "calculator.calculus": "Analyse",
+    "calculator.units": "Unités",
+    "geometry.select": "Sélectionner",
+    "geometry.point": "Point",
+    "geometry.segment": "Segment",
+    "geometry.line": "Droite",
+    "geometry.ray": "Demi-droite",
+    "geometry.circle": "Cercle",
+    "geometry.polygon": "Polygone",
+    "geometry.perpendicular": "Perpendiculaire",
+    "geometry.parallel": "Parallèle",
+    "geometry.midpoint": "Milieu",
+    "geometry.angleBisector": "Bissectrice",
+    "geometry.intersection": "Intersection",
+    "geometry.reflect": "Réflexion",
+    "geometry.rotate": "Rotation",
+    "geometry.measure": "Mesurer",
+    "geometry.arc": "Arc",
+    "geometry.angle": "Angle",
+    "geometry.tangent": "Tangente",
+    "geometry.translate": "Translation",
+    "geometry.dilate": "Homothétie",
+    "geometry.text": "Texte",
+    "geometry.tool": "Outil : {tool}",
+    "geometry.objects": "Objets : {elements}",
+    "geometry.points": "Points : {pointCount}",
+    "geometry.scaleX": "Échelle : {scale}x",
+    "plotter.parametricXTYT": "Paramétrique (x(t), y(t))",
+    "plotter.polarRF": "Polaire r = f(θ)",
+    "plotter.n3dSurfaceZFX": "Surface 3D z = f(x,y)",
+    "plotter.expression": "Expression...",
+    "plotter.addPlot": "+ Ajouter un tracé",
+    "editor.previewRequiresKatexMathjaxIntegration": "Aperçu (nécessite l'intégration KaTeX/MathJax) :"
   },
   es: {
     "calculator.matrixA": "Matriz A",
@@ -114,7 +262,44 @@ const J = {
     "editor.handwritingNote": "Dibuja tu ecuación arriba. El reconocimiento de escritura requiere integración con una API externa.",
     "editor.templates": "Plantillas",
     "editor.copyLatex": "Copiar LaTeX",
-    "plotter.close": "Cerrar"
+    "plotter.close": "Cerrar",
+    "calculator.standard": "Estándar",
+    "calculator.scientific": "Científica",
+    "calculator.programmer": "Programador",
+    "calculator.matrix": "Matriz",
+    "calculator.calculus": "Cálculo",
+    "calculator.units": "Unidades",
+    "geometry.select": "Seleccionar",
+    "geometry.point": "Punto",
+    "geometry.segment": "Segmento",
+    "geometry.line": "Recta",
+    "geometry.ray": "Semirrecta",
+    "geometry.circle": "Circunferencia",
+    "geometry.polygon": "Polígono",
+    "geometry.perpendicular": "Perpendicular",
+    "geometry.parallel": "Paralela",
+    "geometry.midpoint": "Punto medio",
+    "geometry.angleBisector": "Bisectriz",
+    "geometry.intersection": "Intersección",
+    "geometry.reflect": "Reflejar",
+    "geometry.rotate": "Girar",
+    "geometry.measure": "Medir",
+    "geometry.arc": "Arco",
+    "geometry.angle": "Ángulo",
+    "geometry.tangent": "Tangente",
+    "geometry.translate": "Trasladar",
+    "geometry.dilate": "Homotecia",
+    "geometry.text": "Texto",
+    "geometry.tool": "Herramienta: {tool}",
+    "geometry.objects": "Objetos: {elements}",
+    "geometry.points": "Puntos: {pointCount}",
+    "geometry.scaleX": "Escala: {scale}x",
+    "plotter.parametricXTYT": "Paramétrica (x(t), y(t))",
+    "plotter.polarRF": "Polar r = f(θ)",
+    "plotter.n3dSurfaceZFX": "Superficie 3D z = f(x,y)",
+    "plotter.expression": "Expresión...",
+    "plotter.addPlot": "+ Añadir gráfica",
+    "editor.previewRequiresKatexMathjaxIntegration": "Vista previa (requiere integración con KaTeX/MathJax):"
   },
   it: {
     "calculator.matrixA": "Matrice A",
@@ -136,7 +321,44 @@ const J = {
     "editor.handwritingNote": "Disegna la tua equazione qui sopra. Il riconoscimento della scrittura richiede un’integrazione API esterna.",
     "editor.templates": "Modelli",
     "editor.copyLatex": "Copia LaTeX",
-    "plotter.close": "Chiudi"
+    "plotter.close": "Chiudi",
+    "calculator.standard": "Standard",
+    "calculator.scientific": "Scientifica",
+    "calculator.programmer": "Programmatore",
+    "calculator.matrix": "Matrice",
+    "calculator.calculus": "Analisi",
+    "calculator.units": "Unità",
+    "geometry.select": "Seleziona",
+    "geometry.point": "Punto",
+    "geometry.segment": "Segmento",
+    "geometry.line": "Retta",
+    "geometry.ray": "Semiretta",
+    "geometry.circle": "Circonferenza",
+    "geometry.polygon": "Poligono",
+    "geometry.perpendicular": "Perpendicolare",
+    "geometry.parallel": "Parallela",
+    "geometry.midpoint": "Punto medio",
+    "geometry.angleBisector": "Bisettrice",
+    "geometry.intersection": "Intersezione",
+    "geometry.reflect": "Rifletti",
+    "geometry.rotate": "Ruota",
+    "geometry.measure": "Misura",
+    "geometry.arc": "Arco",
+    "geometry.angle": "Angolo",
+    "geometry.tangent": "Tangente",
+    "geometry.translate": "Trasla",
+    "geometry.dilate": "Omotetia",
+    "geometry.text": "Testo",
+    "geometry.tool": "Strumento: {tool}",
+    "geometry.objects": "Oggetti: {elements}",
+    "geometry.points": "Punti: {pointCount}",
+    "geometry.scaleX": "Scala: {scale}x",
+    "plotter.parametricXTYT": "Parametrico (x(t), y(t))",
+    "plotter.polarRF": "Polare r = f(θ)",
+    "plotter.n3dSurfaceZFX": "Superficie 3D z = f(x,y)",
+    "plotter.expression": "Espressione...",
+    "plotter.addPlot": "+ Aggiungi grafico",
+    "editor.previewRequiresKatexMathjaxIntegration": "Anteprima (richiede l'integrazione KaTeX/MathJax):"
   },
   pt: {
     "calculator.matrixA": "Matriz A",
@@ -158,7 +380,44 @@ const J = {
     "editor.handwritingNote": "Desenhe a sua equação acima. O reconhecimento de escrita requer integração com uma API externa.",
     "editor.templates": "Modelos",
     "editor.copyLatex": "Copiar LaTeX",
-    "plotter.close": "Fechar"
+    "plotter.close": "Fechar",
+    "calculator.standard": "Padrão",
+    "calculator.scientific": "Científica",
+    "calculator.programmer": "Programador",
+    "calculator.matrix": "Matriz",
+    "calculator.calculus": "Cálculo",
+    "calculator.units": "Unidades",
+    "geometry.select": "Selecionar",
+    "geometry.point": "Ponto",
+    "geometry.segment": "Segmento",
+    "geometry.line": "Reta",
+    "geometry.ray": "Semirreta",
+    "geometry.circle": "Circunferência",
+    "geometry.polygon": "Polígono",
+    "geometry.perpendicular": "Perpendicular",
+    "geometry.parallel": "Paralela",
+    "geometry.midpoint": "Ponto médio",
+    "geometry.angleBisector": "Bissetriz",
+    "geometry.intersection": "Interseção",
+    "geometry.reflect": "Refletir",
+    "geometry.rotate": "Rodar",
+    "geometry.measure": "Medir",
+    "geometry.arc": "Arco",
+    "geometry.angle": "Ângulo",
+    "geometry.tangent": "Tangente",
+    "geometry.translate": "Transladar",
+    "geometry.dilate": "Homotetia",
+    "geometry.text": "Texto",
+    "geometry.tool": "Ferramenta: {tool}",
+    "geometry.objects": "Objetos: {elements}",
+    "geometry.points": "Pontos: {pointCount}",
+    "geometry.scaleX": "Escala: {scale}x",
+    "plotter.parametricXTYT": "Paramétrico (x(t), y(t))",
+    "plotter.polarRF": "Polar r = f(θ)",
+    "plotter.n3dSurfaceZFX": "Superfície 3D z = f(x,y)",
+    "plotter.expression": "Expressão...",
+    "plotter.addPlot": "+ Adicionar gráfico",
+    "editor.previewRequiresKatexMathjaxIntegration": "Pré-visualização (requer integração KaTeX/MathJax):"
   },
   cs: {
     "calculator.matrixA": "Matice A",
@@ -180,7 +439,44 @@ const J = {
     "editor.handwritingNote": "Nakreslete svou rovnici výše. Rozpoznávání rukopisu vyžaduje externí integraci API.",
     "editor.templates": "Šablony",
     "editor.copyLatex": "Kopírovat LaTeX",
-    "plotter.close": "Zavřít"
+    "plotter.close": "Zavřít",
+    "calculator.standard": "Standardní",
+    "calculator.scientific": "Vědecká",
+    "calculator.programmer": "Programátorská",
+    "calculator.matrix": "Matice",
+    "calculator.calculus": "Analýza",
+    "calculator.units": "Jednotky",
+    "geometry.select": "Vybrat",
+    "geometry.point": "Bod",
+    "geometry.segment": "Úsečka",
+    "geometry.line": "Přímka",
+    "geometry.ray": "Polopřímka",
+    "geometry.circle": "Kružnice",
+    "geometry.polygon": "Mnohoúhelník",
+    "geometry.perpendicular": "Kolmice",
+    "geometry.parallel": "Rovnoběžka",
+    "geometry.midpoint": "Střed",
+    "geometry.angleBisector": "Osa úhlu",
+    "geometry.intersection": "Průsečík",
+    "geometry.reflect": "Zrcadlit",
+    "geometry.rotate": "Otočit",
+    "geometry.measure": "Měřit",
+    "geometry.arc": "Oblouk",
+    "geometry.angle": "Úhel",
+    "geometry.tangent": "Tečna",
+    "geometry.translate": "Posunout",
+    "geometry.dilate": "Stejnolehlost",
+    "geometry.text": "Text",
+    "geometry.tool": "Nástroj: {tool}",
+    "geometry.objects": "Objekty: {elements}",
+    "geometry.points": "Body: {pointCount}",
+    "geometry.scaleX": "Měřítko: {scale}x",
+    "plotter.parametricXTYT": "Parametrický (x(t), y(t))",
+    "plotter.polarRF": "Polární r = f(θ)",
+    "plotter.n3dSurfaceZFX": "3D plocha z = f(x,y)",
+    "plotter.expression": "Výraz...",
+    "plotter.addPlot": "+ Přidat graf",
+    "editor.previewRequiresKatexMathjaxIntegration": "Náhled (vyžaduje integraci KaTeX/MathJax):"
   },
   uk: {
     "calculator.matrixA": "Матриця A",
@@ -202,23 +498,59 @@ const J = {
     "editor.handwritingNote": "Намалюйте своє рівняння вище. Розпізнавання рукопису потребує зовнішньої інтеграції з API.",
     "editor.templates": "Шаблони",
     "editor.copyLatex": "Копіювати LaTeX",
-    "plotter.close": "Закрити"
-  }
-}, ae = /* @__PURE__ */ F({
-  locale: "en",
-  t: (e, t) => t ?? e
-});
-function Qe({ locale: e = "en", overrides: t, children: r }) {
-  const o = he(() => {
-    const a = { ...J.en, ...J[e], ...t };
-    return { locale: e, t: (i, c) => a[i] ?? c ?? i };
-  }, [e, t]);
-  return ye.createElement(ae.Provider, { value: o }, r);
+    "plotter.close": "Закрити",
+    "calculator.standard": "Стандартний",
+    "calculator.scientific": "Науковий",
+    "calculator.programmer": "Програміста",
+    "calculator.matrix": "Матриці",
+    "calculator.calculus": "Аналіз",
+    "calculator.units": "Одиниці",
+    "geometry.select": "Вибрати",
+    "geometry.point": "Точка",
+    "geometry.segment": "Відрізок",
+    "geometry.line": "Пряма",
+    "geometry.ray": "Промінь",
+    "geometry.circle": "Коло",
+    "geometry.polygon": "Многокутник",
+    "geometry.perpendicular": "Перпендикуляр",
+    "geometry.parallel": "Паралельна",
+    "geometry.midpoint": "Середина",
+    "geometry.angleBisector": "Бісектриса",
+    "geometry.intersection": "Перетин",
+    "geometry.reflect": "Відбити",
+    "geometry.rotate": "Повернути",
+    "geometry.measure": "Виміряти",
+    "geometry.arc": "Дуга",
+    "geometry.angle": "Кут",
+    "geometry.tangent": "Дотична",
+    "geometry.translate": "Перенести",
+    "geometry.dilate": "Гомотетія",
+    "geometry.text": "Текст",
+    "geometry.tool": "Інструмент: {tool}",
+    "geometry.objects": "Об'єкти: {elements}",
+    "geometry.points": "Точки: {pointCount}",
+    "geometry.scaleX": "Масштаб: {scale}x",
+    "plotter.parametricXTYT": "Параметричний (x(t), y(t))",
+    "plotter.polarRF": "Полярний r = f(θ)",
+    "plotter.n3dSurfaceZFX": "3D-поверхня z = f(x,y)",
+    "plotter.expression": "Вираз...",
+    "plotter.addPlot": "+ Додати графік",
+    "editor.previewRequiresKatexMathjaxIntegration": "Попередній перегляд (потрібна інтеграція KaTeX/MathJax):"
+  }
+}, ne = /* @__PURE__ */ O(null);
+function ie(e, t) {
+  const r = { ...K.en, ...K[e], ...t };
+  return { locale: e, t: (a, n) => r[a] ?? n ?? a };
+}
+function et({ locale: e = "en", overrides: t, children: r }) {
+  const o = ae(() => ie(e, t), [e, t]);
+  return be.createElement(ne.Provider, { value: o }, r);
 }
-function L() {
-  return j(ae);
+function E() {
+  const e = F(ne), { lang: t } = xe(), r = K[t] ? t : "en", o = ae(() => ie(r), [r]);
+  return e ?? o;
 }
-const fe = [
+const ve = [
   {
     target: ".nice-math-editor",
     titleKey: "tutorial.mathEditor.intro.title",
@@ -227,7 +559,7 @@ const fe = [
     content: "Write equations as LaTeX or insert symbols from the palette; switch to handwriting input, and preview the rendered formula live.",
     placement: "auto"
   }
-], be = [
+], we = [
   // Greek lowercase
   { name: "alpha", latex: "\\alpha", category: "greek", preview: "α" },
   { name: "beta", latex: "\\beta", category: "greek", preview: "β" },
@@ -404,10 +736,10 @@ const fe = [
     preview: "{ }"
   }
 ];
-function ve(e) {
-  return be.filter((t) => t.category === e);
+function ke(e) {
+  return we.filter((t) => t.category === e);
 }
-const we = [
+const Pe = [
   // Basic
   { name: "Fraction", latex: "\\frac{a}{b}", category: "basic" },
   { name: "Square root", latex: "\\sqrt{x}", category: "basic" },
@@ -466,11 +798,11 @@ const we = [
     category: "physics"
   }
 ];
-class ke {
+class Me {
   constructor(t = {}) {
-    T(this, "equations", /* @__PURE__ */ new Map());
-    T(this, "config");
-    T(this, "nextNumber");
+    z(this, "equations", /* @__PURE__ */ new Map());
+    z(this, "config");
+    z(this, "nextNumber");
     this.config = {
       enableNumbering: t.enableNumbering ?? !0,
       startNumber: t.startNumber ?? 1,
@@ -539,8 +871,8 @@ class ke {
       r.push(this.createEquation(a[1].trim()));
     const n = /\\begin\{equation\}([\s\S]*?)\\end\{equation\}/g;
     for (; (a = n.exec(t)) !== null; ) {
-      const i = a[1].match(/\\label\{([^}]+)\}/), c = a[1].replace(/\\label\{[^}]+\}/, "").trim();
-      r.push(this.createEquation(c, i == null ? void 0 : i[1]));
+      const i = a[1].match(/\\label\{([^}]+)\}/), l = a[1].replace(/\\label\{[^}]+\}/, "").trim();
+      r.push(this.createEquation(l, i == null ? void 0 : i[1]));
     }
     return r;
   }
@@ -548,8 +880,8 @@ class ke {
     return Date.now().toString(36) + Math.random().toString(36).substring(2, 8);
   }
 }
-function Je(e) {
-  return new ke(e);
+function tt(e) {
+  return new Me(e);
 }
 async function Ce(e) {
   return await new Promise((r) => setTimeout(r, 500)), {
@@ -558,9 +890,9 @@ async function Ce(e) {
     alternatives: ["x", "X", "\\times"]
   };
 }
-const ne = /* @__PURE__ */ F(null);
+const se = /* @__PURE__ */ O(null);
 function W() {
-  const e = j(ne);
+  const e = F(se);
   if (!e)
     throw new Error("useMathEditor must be used within MathEditorProvider");
   return e;
@@ -648,7 +980,7 @@ const A = {
     cursor: "crosshair"
   }
 };
-function et({
+function rt({
   service: e,
   initialLatex: t = "",
   onChange: r,
@@ -656,67 +988,67 @@ function et({
   style: a,
   tutorial: n
 }) {
-  const { t: i } = L(), [c, u] = P(t), [s, p] = P("input"), m = U(null), y = R(
+  const { t: i } = E(), [l, g] = M(t), [s, p] = M("input"), u = U(null), x = R(
     (b) => {
-      u(b), r == null || r(b);
+      g(b), r == null || r(b);
     },
     [r]
   ), f = R(
     (b) => {
-      const l = m.current;
-      if (!l) {
-        y(c + b);
+      const c = u.current;
+      if (!c) {
+        x(l + b);
         return;
       }
-      const g = l.selectionStart, w = l.selectionEnd, M = c.slice(0, g) + b + c.slice(w);
-      y(M), setTimeout(() => {
-        l.focus(), l.selectionStart = l.selectionEnd = g + b.length;
+      const m = c.selectionStart, k = c.selectionEnd, C = l.slice(0, m) + b + l.slice(k);
+      x(C), setTimeout(() => {
+        c.focus(), c.selectionStart = c.selectionEnd = m + b.length;
       }, 0);
     },
-    [c, y]
-  ), C = R(
+    [l, x]
+  ), w = R(
     (b) => {
       f(b.latex);
     },
     [f]
-  ), x = {
+  ), y = {
     service: e,
-    latex: c,
-    setLatex: y,
+    latex: l,
+    setLatex: x,
     insertSymbol: f,
-    insertTemplate: C,
+    insertTemplate: w,
     mode: s,
     setMode: p
   };
-  return /* @__PURE__ */ d(ne.Provider, { value: x, children: /* @__PURE__ */ v(
-    ge,
+  return /* @__PURE__ */ d(se.Provider, { value: y, children: /* @__PURE__ */ v(
+    ye,
     {
       flush: !0,
       className: `nice-math-editor ${o ?? ""}`,
       style: { position: "relative", ...a },
-      toolbar: /* @__PURE__ */ d(Pe, {}),
-      sidebar: /* @__PURE__ */ d(Me, {}),
+      toolbar: /* @__PURE__ */ d(Se, {}),
+      sidebar: /* @__PURE__ */ d(Be, {}),
       children: [
-        /* @__PURE__ */ d("span", { style: { position: "absolute", top: 6, right: 6, zIndex: 30 }, children: /* @__PURE__ */ d(xe, { steps: me(n, fe) }) }),
+        /* @__PURE__ */ d("span", { style: { position: "absolute", top: 6, right: 6, zIndex: 30 }, children: /* @__PURE__ */ d(he, { steps: fe(n, ve) }) }),
         /* @__PURE__ */ d("div", { style: A.editor, children: s === "input" ? /* @__PURE__ */ v(oe, { children: [
           /* @__PURE__ */ d(
             "textarea",
             {
-              ref: m,
-              value: c,
-              onChange: (b) => y(b.target.value),
+              ref: u,
+              value: l,
+              onChange: (b) => x(b.target.value),
               placeholder: i("editor.latexPlaceholder", "Enter LaTeX equation..."),
               style: A.input
             }
           ),
-          /* @__PURE__ */ d(Se, { latex: c })
-        ] }) : /* @__PURE__ */ d(Be, {}) })
+          /* @__PURE__ */ d(Te, { latex: l })
+        ] }) : /* @__PURE__ */ d(Re, {}) })
       ]
     }
   ) });
 }
-function Pe() {
-  const { t: e } = L(), { mode: t, setMode: r, latex: o, insertTemplate: a } = W(), [n, i] = P(!1);
+function Se() {
+  const { t: e } = E(), { mode: t, setMode: r, latex: o, insertTemplate: a } = W(), [n, i] = M(!1);
   return /* @__PURE__ */ v("div", { style: A.toolbar, children: [
     /* @__PURE__ */ v(
       "button",
@@ -729,7 +1061,7 @@ function Pe() {
           color: t === "input" ? "var(--nice-color-white, #fff)" : "var(--nice-text-primary, #fff)"
         },
         children: [
-          /* @__PURE__ */ d(X, { name: "keyboard", size: 14 }),
+          /* @__PURE__ */ d(N, { name: "keyboard", size: 14 }),
           " ",
           e("editor.latexInput", "LaTeX Input")
         ]
@@ -745,7 +1077,7 @@ function Pe() {
           color: t === "handwriting" ? "var(--nice-color-white, #fff)" : "var(--nice-text-primary, #fff)"
         },
         children: [
-          /* @__PURE__ */ d(X, { name: "pen", size: 14 }),
+          /* @__PURE__ */ d(N, { name: "pen", size: 14 }),
           " ",
           e("editor.handwriting", "Handwriting")
         ]
@@ -763,11 +1095,11 @@ function Pe() {
     ),
     /* @__PURE__ */ v("div", { style: { position: "relative" }, children: [
       /* @__PURE__ */ v("button", { onClick: () => i(!n), style: A.button, children: [
-        /* @__PURE__ */ d(X, { name: "ruler", size: 14 }),
+        /* @__PURE__ */ d(N, { name: "ruler", size: 14 }),
         " ",
         e("editor.templates", "Templates"),
         " ",
-        /* @__PURE__ */ d(X, { name: "chevron-down", size: 12 })
+        /* @__PURE__ */ d(N, { name: "chevron-down", size: 12 })
       ] }),
       n && /* @__PURE__ */ d(
         "div",
@@ -786,13 +1118,13 @@ function Pe() {
             overflow: "auto"
           },
           children: ["basic", "calculus", "algebra", "geometry", "statistics", "physics"].map(
-            (c) => /* @__PURE__ */ v("div", { children: [
-              /* @__PURE__ */ d("div", { style: A.categoryHeader, children: c }),
-              we.filter((u) => u.category === c).map((u) => /* @__PURE__ */ v(
+            (l) => /* @__PURE__ */ v("div", { children: [
+              /* @__PURE__ */ d("div", { style: A.categoryHeader, children: l }),
+              Pe.filter((g) => g.category === l).map((g) => /* @__PURE__ */ v(
                 "div",
                 {
                   onClick: () => {
-                    a(u), i(!1);
+                    a(g), i(!1);
                   },
                   style: {
                     padding: "8px 12px",
@@ -802,7 +1134,7 @@ function Pe() {
                   onMouseOver: (s) => s.target.style.backgroundColor = "var(--nice-bg-secondary, #f5f5f5)",
                   onMouseOut: (s) => s.target.style.backgroundColor = "transparent",
                   children: [
-                    /* @__PURE__ */ d("div", { style: { fontWeight: 500 }, children: u.name }),
+                    /* @__PURE__ */ d("div", { style: { fontWeight: 500 }, children: g.name }),
                     /* @__PURE__ */ v(
                       "div",
                       {
@@ -812,16 +1144,16 @@ function Pe() {
                           fontFamily: "monospace"
                         },
                         children: [
-                          u.latex.substring(0, 40),
-                          u.latex.length > 40 ? "..." : ""
+                          g.latex.substring(0, 40),
+                          g.latex.length > 40 ? "..." : ""
                         ]
                       }
                     )
                   ]
                 },
-                u.name
+                g.name
               ))
-            ] }, c)
+            ] }, l)
           )
         }
       )
@@ -833,7 +1165,7 @@ function Pe() {
         onClick: () => navigator.clipboard.writeText(o),
         style: { ...A.button, backgroundColor: "var(--nice-success, #4caf50)" },
         children: [
-          /* @__PURE__ */ d(X, { name: "copy", size: 14 }),
+          /* @__PURE__ */ d(N, { name: "copy", size: 14 }),
           " ",
           e("editor.copyLatex", "Copy LaTeX")
         ]
@@ -841,8 +1173,8 @@ function Pe() {
     )
   ] });
 }
-function Me() {
-  const { insertSymbol: e } = W(), [t, r] = P("greek"), o = [
+function Be() {
+  const { insertSymbol: e } = W(), [t, r] = M("greek"), o = [
     "greek",
     "operators",
     "relations",
@@ -854,7 +1186,7 @@ function Me() {
     "logic",
     "calculus",
     "matrices"
-  ], a = ve(t);
+  ], a = ke(t);
   return /* @__PURE__ */ v("div", { style: A.sidebar, children: [
     /* @__PURE__ */ d("div", { style: { display: "flex", flexWrap: "wrap", padding: "8px", gap: "4px" }, children: o.map((n) => /* @__PURE__ */ d(
       "button",
@@ -885,94 +1217,98 @@ function Me() {
     )) })
   ] });
 }
-function Se({ latex: e }) {
+function Te({ latex: e }) {
+  const { t } = E();
   return /* @__PURE__ */ v("div", { style: A.preview, children: [
     /* @__PURE__ */ d(
       "div",
       {
         style: { fontSize: "12px", color: "var(--nice-text-secondary, #666)", marginBottom: "8px" },
-        children: "Preview (requires KaTeX/MathJax integration):"
+        children: t(
+          "editor.previewRequiresKatexMathjaxIntegration",
+          "Preview (requires KaTeX/MathJax integration):"
+        )
       }
     ),
     /* @__PURE__ */ d("code", { style: { fontSize: "16px" }, children: e || "(empty)" })
   ] });
 }
-function Be() {
-  const { t: e } = L(), { setLatex: t, setMode: r } = W(), o = U(null), [a, n] = P([]), [i, c] = P([]), [u, s] = P(!1), [p, m] = P(!1), y = (l) => {
-    const g = o.current;
-    if (!g)
+function Re() {
+  const { t: e } = E(), { setLatex: t, setMode: r } = W(), o = U(null), [a, n] = M([]), [i, l] = M([]), [g, s] = M(!1), [p, u] = M(!1), x = (c) => {
+    const m = o.current;
+    if (!m)
       return;
     s(!0);
-    const w = g.getBoundingClientRect();
-    c([
+    const k = m.getBoundingClientRect();
+    l([
       {
-        x: l.clientX - w.left,
-        y: l.clientY - w.top,
-        pressure: l.pressure,
+        x: c.clientX - k.left,
+        y: c.clientY - k.top,
+        pressure: c.pressure,
         timestamp: Date.now()
       }
     ]);
-  }, f = (l) => {
-    if (!u)
+  }, f = (c) => {
+    if (!g)
       return;
-    const g = o.current, w = g == null ? void 0 : g.getContext("2d");
-    if (!g || !w)
+    const m = o.current, k = m == null ? void 0 : m.getContext("2d");
+    if (!m || !k)
       return;
-    const M = g.getBoundingClientRect(), h = {
-      x: l.clientX - M.left,
-      y: l.clientY - M.top,
-      pressure: l.pressure,
+    const C = m.getBoundingClientRect(), h = {
+      x: c.clientX - C.left,
+      y: c.clientY - C.top,
+      pressure: c.pressure,
       timestamp: Date.now()
     };
-    if (c((k) => [...k, h]), i.length > 0) {
-      const k = i[i.length - 1];
-      w.beginPath(), w.moveTo(k.x, k.y), w.lineTo(h.x, h.y), w.strokeStyle = I("var(--nice-text, #000)", w.canvas), w.lineWidth = 2, w.lineCap = "round", w.stroke();
+    if (l((P) => [...P, h]), i.length > 0) {
+      const P = i[i.length - 1];
+      k.beginPath(), k.moveTo(P.x, P.y), k.lineTo(h.x, h.y), k.strokeStyle = D("var(--nice-text, #000)", k.canvas), k.lineWidth = 2, k.lineCap = "round", k.stroke();
     }
-  }, C = () => {
-    if (u) {
+  }, w = () => {
+    if (g) {
       if (s(!1), i.length > 1) {
-        const l = {
+        const c = {
           id: Date.now().toString(),
           points: [...i]
         };
-        n((g) => [...g, l]);
+        n((m) => [...m, c]);
       }
-      c([]);
+      l([]);
     }
-  }, x = () => {
-    const l = o.current, g = l == null ? void 0 : l.getContext("2d");
-    g && l && g.clearRect(0, 0, l.width, l.height), n([]);
+  }, y = () => {
+    const c = o.current, m = c == null ? void 0 : c.getContext("2d");
+    m && c && m.clearRect(0, 0, c.width, c.height), n([]);
   }, b = async () => {
     if (a.length !== 0) {
-      m(!0);
+      u(!0);
       try {
-        const l = await Ce(a);
-        t(l.latex), r("input");
+        const c = await Ce(a);
+        t(c.latex), r("input");
       } finally {
-        m(!1);
+        u(!1);
       }
     }
   };
-  return V(() => {
-    const l = o.current;
-    l && (l.width = l.offsetWidth, l.height = 200);
+  return Y(() => {
+    const c = o.current;
+    c && (c.width = c.offsetWidth, c.height = 200);
   }, []), /* @__PURE__ */ v("div", { children: [
     /* @__PURE__ */ d(
       "canvas",
       {
         ref: o,
         style: A.canvas,
-        onPointerDown: y,
+        onPointerDown: x,
         onPointerMove: f,
-        onPointerUp: C,
-        onPointerLeave: C
+        onPointerUp: w,
+        onPointerLeave: w
       }
     ),
     /* @__PURE__ */ v("div", { style: { display: "flex", gap: "8px", marginTop: "12px" }, children: [
       /* @__PURE__ */ d(
         "button",
         {
-          onClick: x,
+          onClick: y,
           style: { ...A.button, backgroundColor: "var(--nice-danger, #f44336)" },
           children: e("editor.clear", "Clear")
         }
@@ -993,14 +1329,14 @@ function Be() {
     ) })
   ] });
 }
-const $e = {
+const ze = {
   pi: Math.PI,
   PI: Math.PI,
   e: Math.E,
   E: Math.E,
   phi: (1 + Math.sqrt(5)) / 2,
   tau: Math.PI * 2
-}, Re = {
+}, Ae = {
   sin: Math.sin,
   cos: Math.cos,
   tan: Math.tan,
@@ -1032,11 +1368,11 @@ const $e = {
   cot: (e) => 1 / Math.tan(e),
   ln: Math.log
 };
-class ie {
+class le {
   constructor(t = {}) {
-    T(this, "pos", 0);
-    T(this, "expr", "");
-    T(this, "options");
+    z(this, "pos", 0);
+    z(this, "expr", "");
+    z(this, "options");
     this.options = t;
   }
   parse(t) {
@@ -1132,7 +1468,7 @@ class ie {
       case "variable": {
         if (t.name in r)
           return r[t.name];
-        const o = this.lookup({ ...$e, ...this.options.constants }, t.name);
+        const o = this.lookup({ ...ze, ...this.options.constants }, t.name);
         if (o !== void 0)
           return o;
         throw new Error(`Unknown variable: ${t.name}`);
@@ -1157,7 +1493,7 @@ class ie {
         }
       }
       case "call": {
-        const o = this.lookup({ ...Re, ...this.options.functions }, t.name);
+        const o = this.lookup({ ...Ae, ...this.options.functions }, t.name);
         if (!o)
           throw new Error(`Unknown function: ${t.name}`);
         const a = t.args.map((n) => this.evaluate(n, r));
@@ -1168,11 +1504,11 @@ class ie {
     }
   }
 }
-class Te {
+class $e {
   constructor(t = {}) {
-    T(this, "plots", /* @__PURE__ */ new Map());
-    T(this, "parser", new ie());
-    T(this, "config");
+    z(this, "plots", /* @__PURE__ */ new Map());
+    z(this, "parser", new le());
+    z(this, "config");
     this.config = {
       defaultResolution: t.defaultResolution ?? 200,
       maxResolution: t.maxResolution ?? 1e3
@@ -1218,9 +1554,9 @@ class Te {
   }
   /** Compute 2D function points */
   compute2DFunction(t, r, o, a) {
-    const n = this.parser.parse(t), i = [], c = (r.max - r.min) / o;
-    for (let u = 0; u <= o; u++) {
-      const s = r.min + u * c;
+    const n = this.parser.parse(t), i = [], l = (r.max - r.min) / o;
+    for (let g = 0; g <= o; g++) {
+      const s = r.min + g * l;
       try {
         const p = n({ x: s, ...a });
         Number.isFinite(p) && i.push({ x: s, y: p });
@@ -1231,27 +1567,27 @@ class Te {
   }
   /** Compute 2D parametric curve */
   compute2DParametric(t, r, o, a, n) {
-    const i = this.parser.parse(t), c = this.parser.parse(r), u = [], s = (o.max - o.min) / a;
+    const i = this.parser.parse(t), l = this.parser.parse(r), g = [], s = (o.max - o.min) / a;
     for (let p = 0; p <= a; p++) {
-      const m = o.min + p * s;
+      const u = o.min + p * s;
       try {
-        const y = i({ t: m, ...n }), f = c({ t: m, ...n });
-        Number.isFinite(y) && Number.isFinite(f) && u.push({ x: y, y: f });
+        const x = i({ t: u, ...n }), f = l({ t: u, ...n });
+        Number.isFinite(x) && Number.isFinite(f) && g.push({ x, y: f });
       } catch {
       }
     }
-    return u;
+    return g;
   }
   /** Compute 2D polar curve */
   compute2DPolar(t, r, o, a) {
-    const n = this.parser.parse(t), i = [], c = (r.max - r.min) / o;
-    for (let u = 0; u <= o; u++) {
-      const s = r.min + u * c;
+    const n = this.parser.parse(t), i = [], l = (r.max - r.min) / o;
+    for (let g = 0; g <= o; g++) {
+      const s = r.min + g * l;
       try {
         const p = n({ theta: s, t: s, ...a });
         if (Number.isFinite(p)) {
-          const m = p * Math.cos(s), y = p * Math.sin(s);
-          i.push({ x: m, y });
+          const u = p * Math.cos(s), x = p * Math.sin(s);
+          i.push({ x: u, y: x });
         }
       } catch {
       }
@@ -1260,52 +1596,52 @@ class Te {
   }
   /** Compute 3D surface points */
   compute3DSurface(t, r, o, a, n) {
-    const i = this.parser.parse(t), c = [], u = (r.max - r.min) / a, s = (o.max - o.min) / a;
+    const i = this.parser.parse(t), l = [], g = (r.max - r.min) / a, s = (o.max - o.min) / a;
     for (let p = 0; p <= a; p++) {
-      const m = [], y = r.min + p * u;
+      const u = [], x = r.min + p * g;
       for (let f = 0; f <= a; f++) {
-        const C = o.min + f * s;
+        const w = o.min + f * s;
         try {
-          const x = i({ x: y, y: C, ...n });
-          Number.isFinite(x) ? m.push({ x: y, y: C, z: x }) : m.push({ x: y, y: C, z: 0 });
+          const y = i({ x, y: w, ...n });
+          Number.isFinite(y) ? u.push({ x, y: w, z: y }) : u.push({ x, y: w, z: 0 });
         } catch {
-          m.push({ x: y, y: C, z: 0 });
+          u.push({ x, y: w, z: 0 });
         }
       }
-      c.push(m);
+      l.push(u);
     }
-    return c;
+    return l;
   }
   /** Export plot data as SVG */
   exportSVG(t, r, o, a) {
-    const i = o - 80, c = a - 80, u = (m) => 40 + (m - r.xRange.min) / (r.xRange.max - r.xRange.min) * i, s = (m) => a - 40 - (m - r.yRange.min) / (r.yRange.max - r.yRange.min) * c, p = [
+    const i = o - 80, l = a - 80, g = (u) => 40 + (u - r.xRange.min) / (r.xRange.max - r.xRange.min) * i, s = (u) => a - 40 - (u - r.yRange.min) / (r.yRange.max - r.yRange.min) * l, p = [
       `<svg xmlns="http://www.w3.org/2000/svg" width="${o}" height="${a}">`,
       `<rect width="100%" height="100%" fill="rgb(${r.backgroundColor.r},${r.backgroundColor.g},${r.backgroundColor.b})"/>`
     ];
     if (r.showGrid) {
       p.push('<g stroke="var(--nice-border, #ddd)" stroke-width="0.5">');
-      for (let m = Math.ceil(r.xRange.min); m <= r.xRange.max; m++) {
-        const y = u(m);
-        p.push(`<line x1="${y}" y1="40" x2="${y}" y2="${a - 40}"/>`);
+      for (let u = Math.ceil(r.xRange.min); u <= r.xRange.max; u++) {
+        const x = g(u);
+        p.push(`<line x1="${x}" y1="40" x2="${x}" y2="${a - 40}"/>`);
       }
-      for (let m = Math.ceil(r.yRange.min); m <= r.yRange.max; m++) {
-        const y = s(m);
-        p.push(`<line x1="40" y1="${y}" x2="${o - 40}" y2="${y}"/>`);
+      for (let u = Math.ceil(r.yRange.min); u <= r.yRange.max; u++) {
+        const x = s(u);
+        p.push(`<line x1="40" y1="${x}" x2="${o - 40}" y2="${x}"/>`);
       }
       p.push("</g>");
     }
     if (r.showAxes) {
       p.push('<g stroke="var(--nice-text, #333)" stroke-width="1">');
-      const m = s(0), y = u(0);
-      p.push(`<line x1="40" y1="${m}" x2="${o - 40}" y2="${m}"/>`), p.push(`<line x1="${y}" y1="40" x2="${y}" y2="${a - 40}"/>`), p.push("</g>");
+      const u = s(0), x = g(0);
+      p.push(`<line x1="40" y1="${u}" x2="${o - 40}" y2="${u}"/>`), p.push(`<line x1="${x}" y1="40" x2="${x}" y2="${a - 40}"/>`), p.push("</g>");
     }
-    for (const m of t.filter((y) => y.visible))
-      if (m.type === "2d-function") {
-        const y = this.compute2DFunction(m.expression, r.xRange, m.resolution || 200);
-        if (y.length > 0) {
-          const f = y.map((C, x) => `${x === 0 ? "M" : "L"}${u(C.x)},${s(C.y)}`).join(" ");
+    for (const u of t.filter((x) => x.visible))
+      if (u.type === "2d-function") {
+        const x = this.compute2DFunction(u.expression, r.xRange, u.resolution || 200);
+        if (x.length > 0) {
+          const f = x.map((w, y) => `${y === 0 ? "M" : "L"}${g(w.x)},${s(w.y)}`).join(" ");
           p.push(
-            `<path d="${f}" fill="none" stroke="rgb(${m.color.r},${m.color.g},${m.color.b})" stroke-width="${m.lineWidth}"/>`
+            `<path d="${f}" fill="none" stroke="rgb(${u.color.r},${u.color.g},${u.color.b})" stroke-width="${u.lineWidth}"/>`
           );
         }
       }
@@ -1319,26 +1655,26 @@ class Te {
   /** Export as PNG (data URL) */
   async exportPNG(t, r, o, a) {
     const n = this.exportSVG(t, r, o, a);
-    return new Promise((i, c) => {
-      const u = new Image();
-      u.onload = () => {
+    return new Promise((i, l) => {
+      const g = new Image();
+      g.onload = () => {
         const s = document.createElement("canvas");
         s.width = o, s.height = a;
         const p = s.getContext("2d");
         if (!p) {
-          c(new Error("Could not get canvas context"));
+          l(new Error("Could not get canvas context"));
           return;
         }
-        p.drawImage(u, 0, 0), i(s.toDataURL("image/png"));
-      }, u.onerror = c, u.src = "data:image/svg+xml;base64," + btoa(n);
+        p.drawImage(g, 0, 0), i(s.toDataURL("image/png"));
+      }, g.onerror = l, g.src = "data:image/svg+xml;base64," + btoa(n);
     });
   }
   generateId() {
     return Date.now().toString(36) + Math.random().toString(36).substring(2, 8);
   }
 }
-function tt(e) {
-  return new Te(e);
+function ot(e) {
+  return new $e(e);
 }
 const ee = [
   // Basic
@@ -1423,14 +1759,14 @@ const ee = [
     type: "3d-surface",
     category: "3d"
   }
-], se = /* @__PURE__ */ F(null);
-function Y() {
-  const e = j(se);
+], ce = /* @__PURE__ */ O(null);
+function V() {
+  const e = F(ce);
   if (!e)
     throw new Error("useGraph must be used within GraphProvider");
   return e;
 }
-const $ = {
+const T = {
   container: {
     display: "flex",
     height: "100%",
@@ -1489,14 +1825,14 @@ const $ = {
     backgroundColor: "var(--nice-bg-secondary, #fafafa)"
   }
 };
-function rt({
+function at({
   service: e,
   width: t = 800,
   height: r = 600,
   className: o,
   style: a
 }) {
-  const [n, i] = P([]), [c, u] = P({
+  const [n, i] = M([]), [l, g] = M({
     xRange: { min: -10, max: 10 },
     yRange: { min: -10, max: 10 },
     zRange: { min: -5, max: 5 },
@@ -1507,59 +1843,59 @@ function rt({
     cameraRotationX: 30,
     cameraRotationY: 45,
     cameraDistance: 5
-  }), [s, p] = P({
+  }), [s, p] = M({
     isPlaying: !1,
     parameter: "a",
     currentValue: 0,
     minValue: -5,
     maxValue: 5,
     speed: 1
-  }), m = R(() => {
+  }), u = R(() => {
     i(e.getPlots());
-  }, [e]), y = R((g) => {
-    u((w) => ({ ...w, ...g }));
-  }, []), f = R((g) => {
-    p((w) => ({ ...w, ...g }));
-  }, []), C = R(
-    (g) => {
-      e.addPlot(g), m();
+  }, [e]), x = R((m) => {
+    g((k) => ({ ...k, ...m }));
+  }, []), f = R((m) => {
+    p((k) => ({ ...k, ...m }));
+  }, []), w = R(
+    (m) => {
+      e.addPlot(m), u();
     },
-    [e, m]
-  ), x = R(
-    (g) => {
-      e.removePlot(g), m();
+    [e, u]
+  ), y = R(
+    (m) => {
+      e.removePlot(m), u();
     },
-    [e, m]
+    [e, u]
   ), b = R(
-    (g, w) => {
-      e.updatePlot(g, w), m();
+    (m, k) => {
+      e.updatePlot(m, k), u();
     },
-    [e, m]
-  ), l = {
+    [e, u]
+  ), c = {
     service: e,
     plots: n,
-    view: c,
-    setView: y,
-    addPlot: C,
-    removePlot: x,
+    view: l,
+    setView: x,
+    addPlot: w,
+    removePlot: y,
     updatePlot: b,
     animation: s,
     setAnimation: f,
-    refresh: m
+    refresh: u
   };
-  return /* @__PURE__ */ d(se.Provider, { value: l, children: /* @__PURE__ */ v("div", { className: o, style: { ...$.container, ...a }, children: [
-    /* @__PURE__ */ v("div", { style: $.sidebar, children: [
-      /* @__PURE__ */ d(Ae, {}),
-      /* @__PURE__ */ d(ze, {})
+  return /* @__PURE__ */ d(ce.Provider, { value: c, children: /* @__PURE__ */ v("div", { className: o, style: { ...T.container, ...a }, children: [
+    /* @__PURE__ */ v("div", { style: T.sidebar, children: [
+      /* @__PURE__ */ d(Ie, {}),
+      /* @__PURE__ */ d(Ee, {})
     ] }),
-    /* @__PURE__ */ v("div", { style: $.main, children: [
-      /* @__PURE__ */ d(Ee, { width: t, height: r }),
-      /* @__PURE__ */ d(Ie, { width: t, height: r })
+    /* @__PURE__ */ v("div", { style: T.main, children: [
+      /* @__PURE__ */ d(De, { width: t, height: r }),
+      /* @__PURE__ */ d(Le, { width: t, height: r })
     ] })
   ] }) });
 }
-function Ae() {
-  const { t: e } = L(), { addPlot: t } = Y(), [r, o] = P("sin(x)"), [a, n] = P("2d-function"), [i, c] = P("cos(x)"), u = () => {
+function Ie() {
+  const { t: e } = E(), { addPlot: t } = V(), [r, o] = M("sin(x)"), [a, n] = M("2d-function"), [i, l] = M("cos(x)"), g = () => {
     t({
       type: a,
       expression: r,
@@ -1577,12 +1913,12 @@ function Ae() {
       {
         value: a,
         onChange: (s) => n(s.target.value),
-        style: { ...$.input, width: "100%" },
+        style: { ...T.input, width: "100%" },
         children: [
           /* @__PURE__ */ d("option", { value: "2d-function", children: "y = f(x)" }),
-          /* @__PURE__ */ d("option", { value: "2d-parametric", children: "Parametric (x(t), y(t))" }),
-          /* @__PURE__ */ d("option", { value: "2d-polar", children: "Polar r = f(θ)" }),
-          /* @__PURE__ */ d("option", { value: "3d-surface", children: "3D Surface z = f(x,y)" })
+          /* @__PURE__ */ d("option", { value: "2d-parametric", children: e("plotter.parametricXTYT", "Parametric (x(t), y(t))") }),
+          /* @__PURE__ */ d("option", { value: "2d-polar", children: e("plotter.polarRF", "Polar r = f(θ)") }),
+          /* @__PURE__ */ d("option", { value: "3d-surface", children: e("plotter.n3dSurfaceZFX", "3D Surface z = f(x,y)") })
         ]
       }
     ) }),
@@ -1592,8 +1928,8 @@ function Ae() {
         type: "text",
         value: r,
         onChange: (s) => o(s.target.value),
-        placeholder: a === "2d-parametric" ? "x(t) = ..." : "Expression...",
-        style: { ...$.input, width: "100%" }
+        placeholder: a === "2d-parametric" ? "x(t) = ..." : e("plotter.expression", "Expression..."),
+        style: { ...T.input, width: "100%" }
       }
     ) }),
     a === "2d-parametric" && /* @__PURE__ */ d("div", { style: { marginBottom: "8px" }, children: /* @__PURE__ */ d(
@@ -1601,17 +1937,17 @@ function Ae() {
       {
         type: "text",
         value: i,
-        onChange: (s) => c(s.target.value),
+        onChange: (s) => l(s.target.value),
         placeholder: "y(t) = ...",
-        style: { ...$.input, width: "100%" }
+        style: { ...T.input, width: "100%" }
       }
     ) }),
-    /* @__PURE__ */ d("button", { onClick: u, style: { ...$.button, width: "100%" }, children: "+ Add Plot" }),
+    /* @__PURE__ */ d("button", { onClick: g, style: { ...T.button, width: "100%" }, children: e("plotter.addPlot", "+ Add Plot") }),
     /* @__PURE__ */ v(
       "select",
       {
         onChange: (s) => {
-          const p = ee.find((m) => m.name === s.target.value);
+          const p = ee.find((u) => u.name === s.target.value);
           p && t({
             type: p.type,
             expression: p.expression,
@@ -1624,7 +1960,7 @@ function Ae() {
             }
           });
         },
-        style: { ...$.input, width: "100%", marginTop: "8px" },
+        style: { ...T.input, width: "100%", marginTop: "8px" },
         value: "",
         children: [
           /* @__PURE__ */ d("option", { value: "", disabled: !0, children: e("plotter.quickAdd", "Quick add preset...") }),
@@ -1638,9 +1974,9 @@ function Ae() {
     )
   ] });
 }
-function ze() {
-  const { t: e } = L(), { plots: t, removePlot: r, updatePlot: o } = Y();
-  return /* @__PURE__ */ v("div", { style: $.plotList, children: [
+function Ee() {
+  const { t: e } = E(), { plots: t, removePlot: r, updatePlot: o } = V();
+  return /* @__PURE__ */ v("div", { style: T.plotList, children: [
     t.length === 0 && /* @__PURE__ */ d(
       "div",
       {
@@ -1652,7 +1988,7 @@ function ze() {
         children: e("plotter.noPlots", "No plots added yet")
       }
     ),
-    t.map((a) => /* @__PURE__ */ v("div", { style: $.plotItem, children: [
+    t.map((a) => /* @__PURE__ */ v("div", { style: T.plotItem, children: [
       /* @__PURE__ */ v("div", { style: { display: "flex", alignItems: "center", gap: "8px", marginBottom: "8px" }, children: [
         /* @__PURE__ */ d(
           "input",
@@ -1688,7 +2024,7 @@ function ze() {
               cursor: "pointer",
               fontSize: "12px"
             },
-            children: /* @__PURE__ */ d(G, { name: "close", size: 14 })
+            children: /* @__PURE__ */ d(j, { name: "close", size: 14 })
           }
         )
       ] }),
@@ -1712,15 +2048,15 @@ function ze() {
     ] }, a.id))
   ] });
 }
-function Ee({ width: e, height: t }) {
-  const { t: r } = L(), { service: o, plots: a, view: n, setView: i } = Y(), c = () => {
-    const s = o.exportSVG(a, n, e, t), p = new Blob([s], { type: "image/svg+xml" }), m = URL.createObjectURL(p), y = document.createElement("a");
-    y.href = m, y.download = "graph.svg", y.click(), URL.revokeObjectURL(m);
-  }, u = async () => {
+function De({ width: e, height: t }) {
+  const { t: r } = E(), { service: o, plots: a, view: n, setView: i } = V(), l = () => {
+    const s = o.exportSVG(a, n, e, t), p = new Blob([s], { type: "image/svg+xml" }), u = URL.createObjectURL(p), x = document.createElement("a");
+    x.href = u, x.download = "graph.svg", x.click(), URL.revokeObjectURL(u);
+  }, g = async () => {
     const s = await o.exportPNG(a, n, e, t), p = document.createElement("a");
     p.href = s, p.download = "graph.png", p.click();
   };
-  return /* @__PURE__ */ v("div", { style: $.toolbar, children: [
+  return /* @__PURE__ */ v("div", { style: T.toolbar, children: [
     /* @__PURE__ */ v("label", { style: { fontSize: "12px" }, children: [
       "X: [",
       " ",
@@ -1730,7 +2066,7 @@ function Ee({ width: e, height: t }) {
           type: "number",
           value: n.xRange.min,
           onChange: (s) => i({ xRange: { ...n.xRange, min: Number(s.target.value) } }),
-          style: { ...$.input, width: "50px" }
+          style: { ...T.input, width: "50px" }
         }
       ),
       ",",
@@ -1741,7 +2077,7 @@ function Ee({ width: e, height: t }) {
           type: "number",
           value: n.xRange.max,
           onChange: (s) => i({ xRange: { ...n.xRange, max: Number(s.target.value) } }),
-          style: { ...$.input, width: "50px" }
+          style: { ...T.input, width: "50px" }
         }
       ),
       "]"
@@ -1755,7 +2091,7 @@ function Ee({ width: e, height: t }) {
           type: "number",
           value: n.yRange.min,
           onChange: (s) => i({ yRange: { ...n.yRange, min: Number(s.target.value) } }),
-          style: { ...$.input, width: "50px" }
+          style: { ...T.input, width: "50px" }
         }
       ),
       ",",
@@ -1766,7 +2102,7 @@ function Ee({ width: e, height: t }) {
           type: "number",
           value: n.yRange.max,
           onChange: (s) => i({ yRange: { ...n.yRange, max: Number(s.target.value) } }),
-          style: { ...$.input, width: "50px" }
+          style: { ...T.input, width: "50px" }
         }
       ),
       "]"
@@ -1797,10 +2133,10 @@ function Ee({ width: e, height: t }) {
     /* @__PURE__ */ v(
       "button",
       {
-        onClick: c,
-        style: { ...$.button, backgroundColor: "var(--nice-success, #4caf50)" },
+        onClick: l,
+        style: { ...T.button, backgroundColor: "var(--nice-success, #4caf50)" },
         children: [
-          /* @__PURE__ */ d(G, { name: "download", size: 14 }),
+          /* @__PURE__ */ d(j, { name: "download", size: 14 }),
           " SVG"
         ]
       }
@@ -1808,97 +2144,97 @@ function Ee({ width: e, height: t }) {
     /* @__PURE__ */ v(
       "button",
       {
-        onClick: u,
-        style: { ...$.button, backgroundColor: "var(--nice-warning, #ff9800)" },
+        onClick: g,
+        style: { ...T.button, backgroundColor: "var(--nice-warning, #ff9800)" },
         children: [
-          /* @__PURE__ */ d(G, { name: "download", size: 14 }),
+          /* @__PURE__ */ d(j, { name: "download", size: 14 }),
           " PNG"
         ]
       }
     )
   ] });
 }
-function Ie({ width: e, height: t }) {
-  const r = U(null), { service: o, plots: a, view: n, animation: i } = Y(), c = 40;
-  return V(() => {
-    const u = r.current, s = u == null ? void 0 : u.getContext("2d");
-    if (!u || !s)
+function Le({ width: e, height: t }) {
+  const r = U(null), { service: o, plots: a, view: n, animation: i } = V(), l = 40;
+  return Y(() => {
+    const g = r.current, s = g == null ? void 0 : g.getContext("2d");
+    if (!g || !s)
       return;
     s.fillStyle = `rgb(${n.backgroundColor.r},${n.backgroundColor.g},${n.backgroundColor.b})`, s.fillRect(0, 0, e, t);
-    const p = e - c * 2, m = t - c * 2, y = (x) => c + (x - n.xRange.min) / (n.xRange.max - n.xRange.min) * p, f = (x) => t - c - (x - n.yRange.min) / (n.yRange.max - n.yRange.min) * m;
+    const p = e - l * 2, u = t - l * 2, x = (y) => l + (y - n.xRange.min) / (n.xRange.max - n.xRange.min) * p, f = (y) => t - l - (y - n.yRange.min) / (n.yRange.max - n.yRange.min) * u;
     if (n.showGrid) {
-      s.strokeStyle = I("var(--nice-border, #e0e0e0)", s.canvas), s.lineWidth = 0.5;
-      for (let x = Math.ceil(n.xRange.min); x <= n.xRange.max; x++) {
-        const b = y(x);
-        s.beginPath(), s.moveTo(b, c), s.lineTo(b, t - c), s.stroke();
+      s.strokeStyle = D("var(--nice-border, #e0e0e0)", s.canvas), s.lineWidth = 0.5;
+      for (let y = Math.ceil(n.xRange.min); y <= n.xRange.max; y++) {
+        const b = x(y);
+        s.beginPath(), s.moveTo(b, l), s.lineTo(b, t - l), s.stroke();
       }
-      for (let x = Math.ceil(n.yRange.min); x <= n.yRange.max; x++) {
-        const b = f(x);
-        s.beginPath(), s.moveTo(c, b), s.lineTo(e - c, b), s.stroke();
+      for (let y = Math.ceil(n.yRange.min); y <= n.yRange.max; y++) {
+        const b = f(y);
+        s.beginPath(), s.moveTo(l, b), s.lineTo(e - l, b), s.stroke();
       }
     }
     if (n.showAxes) {
-      s.strokeStyle = I("var(--nice-text, #333)", s.canvas), s.lineWidth = 1;
-      const x = f(0);
-      s.beginPath(), s.moveTo(c, x), s.lineTo(e - c, x), s.stroke();
-      const b = y(0);
-      if (s.beginPath(), s.moveTo(b, c), s.lineTo(b, t - c), s.stroke(), n.showLabels) {
-        s.fillStyle = I("var(--nice-text, #333)", s.canvas), s.font = "12px sans-serif", s.textAlign = "center", s.fillText("x", e - c + 15, x + 4), s.fillText("y", b, c - 10), s.font = "10px sans-serif";
-        for (let l = Math.ceil(n.xRange.min); l <= n.xRange.max; l++)
-          l !== 0 && s.fillText(String(l), y(l), x + 15);
-        for (let l = Math.ceil(n.yRange.min); l <= n.yRange.max; l++)
-          l !== 0 && (s.textAlign = "right", s.fillText(String(l), b - 5, f(l) + 4));
+      s.strokeStyle = D("var(--nice-text, #333)", s.canvas), s.lineWidth = 1;
+      const y = f(0);
+      s.beginPath(), s.moveTo(l, y), s.lineTo(e - l, y), s.stroke();
+      const b = x(0);
+      if (s.beginPath(), s.moveTo(b, l), s.lineTo(b, t - l), s.stroke(), n.showLabels) {
+        s.fillStyle = D("var(--nice-text, #333)", s.canvas), s.font = "12px sans-serif", s.textAlign = "center", s.fillText("x", e - l + 15, y + 4), s.fillText("y", b, l - 10), s.font = "10px sans-serif";
+        for (let c = Math.ceil(n.xRange.min); c <= n.xRange.max; c++)
+          c !== 0 && s.fillText(String(c), x(c), y + 15);
+        for (let c = Math.ceil(n.yRange.min); c <= n.yRange.max; c++)
+          c !== 0 && (s.textAlign = "right", s.fillText(String(c), b - 5, f(c) + 4));
       }
     }
-    const C = i.isPlaying ? { [i.parameter]: i.currentValue } : {};
-    for (const x of a.filter((b) => b.visible)) {
-      const b = `rgb(${x.color.r},${x.color.g},${x.color.b})`;
-      s.strokeStyle = b, s.lineWidth = x.lineWidth || 2;
-      let l = [];
-      switch (x.type) {
+    const w = i.isPlaying ? { [i.parameter]: i.currentValue } : {};
+    for (const y of a.filter((b) => b.visible)) {
+      const b = `rgb(${y.color.r},${y.color.g},${y.color.b})`;
+      s.strokeStyle = b, s.lineWidth = y.lineWidth || 2;
+      let c = [];
+      switch (y.type) {
         case "2d-function":
-          l = o.compute2DFunction(
-            x.expression,
+          c = o.compute2DFunction(
+            y.expression,
             n.xRange,
-            x.resolution || 200,
-            C
+            y.resolution || 200,
+            w
           );
           break;
         case "2d-parametric":
-          l = o.compute2DParametric(
-            x.expression,
-            x.expressionY || "sin(t)",
-            x.parameterRange || { min: 0, max: 2 * Math.PI },
-            x.resolution || 200,
-            C
+          c = o.compute2DParametric(
+            y.expression,
+            y.expressionY || "sin(t)",
+            y.parameterRange || { min: 0, max: 2 * Math.PI },
+            y.resolution || 200,
+            w
           );
           break;
         case "2d-polar":
-          l = o.compute2DPolar(
-            x.expression,
-            x.parameterRange || { min: 0, max: 2 * Math.PI },
-            x.resolution || 200,
-            C
+          c = o.compute2DPolar(
+            y.expression,
+            y.parameterRange || { min: 0, max: 2 * Math.PI },
+            y.resolution || 200,
+            w
           );
           break;
       }
-      if (l.length > 0) {
+      if (c.length > 0) {
         s.beginPath();
-        let g = !1;
-        for (const w of l) {
-          const M = y(w.x), h = f(w.y);
+        let m = !1;
+        for (const k of c) {
+          const C = x(k.x), h = f(k.y);
           if (h < 0 || h > t) {
-            g = !1;
+            m = !1;
             continue;
           }
-          g ? s.lineTo(M, h) : (s.moveTo(M, h), g = !0);
+          m ? s.lineTo(C, h) : (s.moveTo(C, h), m = !0);
         }
         s.stroke();
       }
     }
-  }, [a, n, i, o, e, t]), /* @__PURE__ */ d("canvas", { ref: r, width: e, height: t, style: $.canvas });
+  }, [a, n, i, o, e, t]), /* @__PURE__ */ d("canvas", { ref: r, width: e, height: t, style: T.canvas });
 }
-const O = [
+const G = [
   // Length
   { name: "Meter", symbol: "m", category: "Length", toBase: (e) => e, fromBase: (e) => e },
   {
@@ -2168,7 +2504,7 @@ const O = [
     fromBase: (e) => e / 1099511627776
   },
   { name: "Bit", symbol: "bit", category: "Data", toBase: (e) => e / 8, fromBase: (e) => e * 8 }
-], z = {
+], $ = {
   create(e, t, r = 0) {
     const o = [];
     for (let a = 0; a < e; a++)
@@ -2245,8 +2581,8 @@ const O = [
       if (n === t)
         continue;
       let i = 0;
-      for (let c = 0; c < e.cols; c++)
-        c !== r && (o.data[a][i] = e.data[n][c], i++);
+      for (let l = 0; l < e.cols; l++)
+        l !== r && (o.data[a][i] = e.data[n][l], i++);
       a++;
     }
     return o;
@@ -2258,8 +2594,8 @@ const O = [
     const r = e.rows, o = this.create(r, r);
     for (let a = 0; a < r; a++)
       for (let n = 0; n < r; n++) {
-        const i = Math.pow(-1, a + n), c = this.determinant(this.minor(e, a, n));
-        o.data[n][a] = i * c;
+        const i = Math.pow(-1, a + n), l = this.determinant(this.minor(e, a, n));
+        o.data[n][a] = i * l;
       }
     return this.scalar(o, 1 / t);
   },
@@ -2274,11 +2610,11 @@ const O = [
   eigenvalues2x2(e) {
     if (e.rows !== 2 || e.cols !== 2)
       throw new Error("Only 2x2 matrices supported for eigenvalues");
-    const t = e.data[0][0], r = e.data[0][1], o = e.data[1][0], a = e.data[1][1], n = t + a, i = t * a - r * o, c = n * n - 4 * i;
-    if (c < 0)
+    const t = e.data[0][0], r = e.data[0][1], o = e.data[1][0], a = e.data[1][1], n = t + a, i = t * a - r * o, l = n * n - 4 * i;
+    if (l < 0)
       throw new Error("Complex eigenvalues not supported");
-    const u = Math.sqrt(c);
-    return [(n + u) / 2, (n - u) / 2];
+    const g = Math.sqrt(l);
+    return [(n + g) / 2, (n - g) / 2];
   },
   toString(e, t = 4) {
     return e.data.map((r) => "[ " + r.map((o) => o.toFixed(t).padStart(10)).join(" ") + " ]").join(`
@@ -2299,8 +2635,8 @@ const O = [
     const a = (r - t) / o;
     let n = e(t) + e(r);
     for (let i = 1; i < o; i++) {
-      const c = t + i * a;
-      n += i % 2 === 0 ? 2 * e(c) : 4 * e(c);
+      const l = t + i * a;
+      n += i % 2 === 0 ? 2 * e(l) : 4 * e(l);
     }
     return a / 3 * n;
   },
@@ -2311,10 +2647,10 @@ const O = [
       const i = e(a);
       if (Math.abs(i) < r)
         return a;
-      const c = this.derivative(e, a);
-      if (c === 0)
+      const l = this.derivative(e, a);
+      if (l === 0)
         throw new Error("Derivative is zero, Newton-Raphson failed");
-      a = a - i / c;
+      a = a - i / l;
     }
     throw new Error("Newton-Raphson did not converge");
   },
@@ -2360,12 +2696,12 @@ const O = [
     return [(-t + a) / (2 * e), (-t - a) / (2 * e)];
   }
 };
-class Le {
+class qe {
   constructor(t = {}) {
-    T(this, "history", []);
-    T(this, "memory", 0);
-    T(this, "variables", /* @__PURE__ */ new Map());
-    T(this, "config");
+    z(this, "history", []);
+    z(this, "memory", 0);
+    z(this, "variables", /* @__PURE__ */ new Map());
+    z(this, "config");
     this.config = {
       precision: t.precision ?? 12,
       angleUnit: t.angleUnit ?? "rad"
@@ -2378,24 +2714,24 @@ class Le {
    * `log` is base 10 like the key, `ln` natural; trig functions follow `angleUnit`.
    */
   evaluate(t) {
-    const r = this.config.angleUnit === "deg", o = (c) => r ? c * Math.PI / 180 : c, a = (c) => r ? c * 180 / Math.PI : c, n = new ie({
+    const r = this.config.angleUnit === "deg", o = (l) => r ? l * Math.PI / 180 : l, a = (l) => r ? l * 180 / Math.PI : l, n = new le({
       strict: !0,
       ignoreCase: !0,
       functions: {
         log: Math.log10,
-        sin: (c) => Math.sin(o(c)),
-        cos: (c) => Math.cos(o(c)),
-        tan: (c) => Math.tan(o(c)),
-        asin: (c) => a(Math.asin(c)),
-        acos: (c) => a(Math.acos(c)),
-        atan: (c) => a(Math.atan(c))
+        sin: (l) => Math.sin(o(l)),
+        cos: (l) => Math.cos(o(l)),
+        tan: (l) => Math.tan(o(l)),
+        asin: (l) => a(Math.asin(l)),
+        acos: (l) => a(Math.acos(l)),
+        atan: (l) => a(Math.atan(l))
       }
     });
     let i;
     try {
       i = n.parse(t)(Object.fromEntries(this.variables));
-    } catch (c) {
-      throw new Error(`Invalid expression: ${c.message}`);
+    } catch (l) {
+      throw new Error(`Invalid expression: ${l.message}`);
     }
     if (!Number.isFinite(i))
       throw new Error("Invalid expression: Invalid result");
@@ -2448,7 +2784,7 @@ class Le {
   }
   /** Convert units */
   convertUnits(t, r, o) {
-    const a = O.find((c) => c.symbol === r), n = O.find((c) => c.symbol === o);
+    const a = G.find((l) => l.symbol === r), n = G.find((l) => l.symbol === o);
     if (!a || !n)
       throw new Error("Unknown unit");
     if (a.category !== n.category)
@@ -2458,11 +2794,11 @@ class Le {
   }
   /** Get units by category */
   getUnitsByCategory(t) {
-    return O.filter((r) => r.category === t);
+    return G.filter((r) => r.category === t);
   }
   /** Get all unit categories */
   getUnitCategories() {
-    return [...new Set(O.map((t) => t.category))];
+    return [...new Set(G.map((t) => t.category))];
   }
   /** Format number with precision */
   format(t) {
@@ -2470,12 +2806,12 @@ class Le {
     return Math.abs(t) < 1e-10 ? "0" : Math.abs(t) > 1e10 || Math.abs(t) < 1e-6 ? t.toExponential(r) : parseFloat(t.toPrecision(r)).toString();
   }
 }
-function ot(e) {
-  return new Le(e);
+function nt(e) {
+  return new qe(e);
 }
-const ce = /* @__PURE__ */ F(null);
-function N() {
-  const e = j(ce);
+const de = /* @__PURE__ */ O(null);
+function X() {
+  const e = F(de);
   if (!e)
     throw new Error("useCalculator must be used within CalculatorProvider");
   return e;
@@ -2538,76 +2874,77 @@ const B = {
     backgroundColor: "var(--nice-bg-tertiary, #505050)"
   }
 };
-function at({
+function it({
   service: e,
   className: t,
   style: r
 }) {
-  const [o, a] = P("0"), [n, i] = P("standard"), [c, u] = P([]), [s, p] = P(!1), m = R(
-    (x) => {
-      s && /[0-9.]/.test(x) ? (a(x), p(!1)) : (a((b) => b === "0" && x !== "." ? x : b + x), p(!1));
+  const [o, a] = M("0"), [n, i] = M("standard"), [l, g] = M([]), [s, p] = M(!1), u = R(
+    (y) => {
+      s && /[0-9.]/.test(y) ? (a(y), p(!1)) : (a((b) => b === "0" && y !== "." ? y : b + y), p(!1));
     },
     [s]
-  ), y = R(() => {
+  ), x = R(() => {
     a("0"), p(!1);
   }, []), f = R(() => {
     try {
-      const x = e.evaluate(o), b = e.format(x);
-      e.addHistory(o, b, n), u(e.getHistory()), a(b), p(!0);
+      const y = e.evaluate(o), b = e.format(y);
+      e.addHistory(o, b, n), g(e.getHistory()), a(b), p(!0);
     } catch {
       a("Error"), p(!0);
     }
-  }, [o, n, e]), C = {
+  }, [o, n, e]), w = {
     service: e,
     display: o,
     setDisplay: a,
     mode: n,
     setMode: i,
-    history: c,
+    history: l,
     calculate: f,
-    appendDigit: m,
-    clear: y
+    appendDigit: u,
+    clear: x
   };
-  return /* @__PURE__ */ d(ce.Provider, { value: C, children: /* @__PURE__ */ v("div", { className: t, style: { ...B.container, ...r }, children: [
-    /* @__PURE__ */ d(De, {}),
-    /* @__PURE__ */ d(qe, {}),
-    n === "standard" && /* @__PURE__ */ d(le, {}),
-    n === "scientific" && /* @__PURE__ */ d(Ne, {}),
-    n === "programmer" && /* @__PURE__ */ d(Xe, {}),
-    n === "matrix" && /* @__PURE__ */ d(Ge, {}),
-    n === "calculus" && /* @__PURE__ */ d(je, {}),
-    n === "units" && /* @__PURE__ */ d(Fe, {})
+  return /* @__PURE__ */ d(de.Provider, { value: w, children: /* @__PURE__ */ v("div", { className: t, style: { ...B.container, ...r }, children: [
+    /* @__PURE__ */ d(Xe, {}),
+    /* @__PURE__ */ d(Ne, {}),
+    n === "standard" && /* @__PURE__ */ d(pe, {}),
+    n === "scientific" && /* @__PURE__ */ d(je, {}),
+    n === "programmer" && /* @__PURE__ */ d(Fe, {}),
+    n === "matrix" && /* @__PURE__ */ d(Oe, {}),
+    n === "calculus" && /* @__PURE__ */ d(Ge, {}),
+    n === "units" && /* @__PURE__ */ d(Ue, {})
   ] }) });
 }
-function De() {
-  const { mode: e, setMode: t } = N(), r = [
-    { id: "standard", label: "Standard" },
-    { id: "scientific", label: "Scientific" },
-    { id: "programmer", label: "Programmer" },
-    { id: "matrix", label: "Matrix" },
-    { id: "calculus", label: "Calculus" },
-    { id: "units", label: "Units" }
+function Xe() {
+  const { t: e } = E(), { mode: t, setMode: r } = X(), o = [
+    { id: "standard", label: e("calculator.standard", "Standard") },
+    { id: "scientific", label: e("calculator.scientific", "Scientific") },
+    { id: "programmer", label: e("calculator.programmer", "Programmer") },
+    { id: "matrix", label: e("calculator.matrix", "Matrix") },
+    { id: "calculus", label: e("calculator.calculus", "Calculus") },
+    { id: "units", label: e("calculator.units", "Units") }
   ];
-  return /* @__PURE__ */ d("div", { style: B.modeSelector, children: r.map((o) => /* @__PURE__ */ d(
+  return /* @__PURE__ */ d("div", { style: B.modeSelector, children: o.map((a) => /* @__PURE__ */ d(
     "button",
     {
-      onClick: () => t(o.id),
+      onClick: () => r(a.id),
       style: {
         ...B.modeButton,
-        backgroundColor: e === o.id ? "var(--nice-primary-hover, #1976d2)" : "transparent",
-        color: e === o.id ? "var(--nice-color-white, #fff)" : "var(--nice-text-secondary, #888)"
+        backgroundColor: t === a.id ? "var(--nice-primary-hover, #1976d2)" : "transparent",
+        color: t === a.id ? "var(--nice-color-white, #fff)" : "var(--nice-text-secondary, #888)"
       },
-      children: o.label
+      children: a.label
     },
-    o.id
+    a.id
   )) });
 }
-function qe() {
-  const { display: e } = N();
+function Ne() {
+  const { display: e } = X();
   return /* @__PURE__ */ d("div", { style: B.display, children: /* @__PURE__ */ d("div", { style: B.displayText, children: e }) });
 }
-function le() {
-  const { appendDigit: e, clear: t, calculate: r, setDisplay: o, display: a } = N(), n = [
+function pe() {
+  const { appendDigit: e, clear: t, calculate: r, setDisplay: o, display: a } = X(), n = [
+    // audit-allow: i18n — the calculator key, the same in every language
     { label: "AC", action: t, style: B.keyFunction },
     {
       label: "±",
@@ -2633,16 +2970,16 @@ function le() {
     { label: "⌫", action: () => o(a.length > 1 ? a.slice(0, -1) : "0") },
     { label: "=", action: r, style: B.keyOperator }
   ];
-  return /* @__PURE__ */ d("div", { style: B.keypad, children: n.map((i, c) => /* @__PURE__ */ d("button", { onClick: i.action, style: { ...B.key, ...i.style || {} }, children: i.label }, c)) });
+  return /* @__PURE__ */ d("div", { style: B.keypad, children: n.map((i, l) => /* @__PURE__ */ d("button", { onClick: i.action, style: { ...B.key, ...i.style || {} }, children: i.label }, l)) });
 }
-function Ne() {
+function je() {
   const {
     appendDigit: e,
     clear: t,
     calculate: r,
     setDisplay: o,
     display: a
-  } = N(), n = [
+  } = X(), n = [
     { label: "sin", action: () => e("sin(") },
     { label: "cos", action: () => e("cos(") },
     { label: "tan", action: () => e("tan(") },
@@ -2651,34 +2988,37 @@ function Ne() {
   ], i = [
     { label: "x²", action: () => e("^2") },
     { label: "x³", action: () => e("^3") },
+    // audit-allow: i18n — math notation
     { label: "xʸ", action: () => e("^") },
     { label: "√", action: () => e("sqrt(") },
+    // audit-allow: i18n — math notation
     { label: "eˣ", action: () => e("exp(") }
-  ], c = [
+  ], l = [
     { label: "(", action: () => e("(") },
     { label: ")", action: () => e(")") },
     { label: "π", action: () => e("π") },
     { label: "e", action: () => e("e") },
+    // audit-allow: i18n — the calculator key, the same in every language
     { label: "AC", action: t }
   ];
   return /* @__PURE__ */ v("div", { children: [
-    /* @__PURE__ */ d("div", { style: { ...B.keypad, gridTemplateColumns: "repeat(5, 1fr)" }, children: [...n, ...i, ...c].map((u, s) => /* @__PURE__ */ d(
+    /* @__PURE__ */ d("div", { style: { ...B.keypad, gridTemplateColumns: "repeat(5, 1fr)" }, children: [...n, ...i, ...l].map((g, s) => /* @__PURE__ */ d(
       "button",
       {
-        onClick: u.action,
+        onClick: g.action,
         style: { ...B.key, ...B.keyFunction, padding: "12px" },
-        children: u.label
+        children: g.label
       },
       s
     )) }),
-    /* @__PURE__ */ d(le, {})
+    /* @__PURE__ */ d(pe, {})
   ] });
 }
-function Xe() {
-  const { display: e, setDisplay: t, service: r } = N(), [o, a] = P("DEC"), n = (c) => {
+function Fe() {
+  const { display: e, setDisplay: t, service: r } = X(), [o, a] = M("DEC"), n = (l) => {
     try {
-      const u = r.convertBase(e, o, c);
-      t(u), a(c);
+      const g = r.convertBase(e, o, l);
+      t(g), a(l);
     } catch {
       t("Error");
     }
@@ -2693,33 +3033,33 @@ function Xe() {
           padding: "8px",
           backgroundColor: "var(--nice-bg-secondary, #252525)"
         },
-        children: ["BIN", "OCT", "DEC", "HEX"].map((c) => /* @__PURE__ */ d(
+        children: ["BIN", "OCT", "DEC", "HEX"].map((l) => /* @__PURE__ */ d(
           "button",
           {
-            onClick: () => n(c),
+            onClick: () => n(l),
             style: {
               flex: 1,
               padding: "8px",
               border: "none",
               borderRadius: "4px",
-              backgroundColor: o === c ? "var(--nice-primary-hover, #1976d2)" : "var(--nice-border, #3c3c3c)",
+              backgroundColor: o === l ? "var(--nice-primary-hover, #1976d2)" : "var(--nice-border, #3c3c3c)",
               color: "var(--nice-color-white, #fff)",
               cursor: "pointer"
             },
-            children: c
+            children: l
           },
-          c
+          l
         ))
       }
     ),
-    i.length > 0 && /* @__PURE__ */ d("div", { style: { ...B.keypad, gridTemplateColumns: "repeat(6, 1fr)" }, children: i.map((c) => /* @__PURE__ */ d(
+    i.length > 0 && /* @__PURE__ */ d("div", { style: { ...B.keypad, gridTemplateColumns: "repeat(6, 1fr)" }, children: i.map((l) => /* @__PURE__ */ d(
       "button",
       {
-        onClick: () => t(e === "0" ? c : e + c),
+        onClick: () => t(e === "0" ? l : e + l),
         style: B.key,
-        children: c
+        children: l
       },
-      c
+      l
     )) }),
     /* @__PURE__ */ d("div", { style: { ...B.keypad, gridTemplateColumns: "repeat(4, 1fr)" }, children: [
       "7",
@@ -2738,31 +3078,33 @@ function Xe() {
       "NOT",
       "<<",
       ">>"
-    ].map((c) => {
-      const u = ["AND", "OR", "XOR", "NOT", "<<", ">>"].includes(c);
+    ].map((l) => {
+      const g = ["AND", "OR", "XOR", "NOT", "<<", ">>"].includes(l);
       return /* @__PURE__ */ d(
         "button",
         {
-          onClick: () => t(e === "0" ? c : e + c),
-          style: { ...B.key, ...u ? B.keyFunction : {} },
-          children: c
+          onClick: () => t(e === "0" ? l : e + l),
+          style: { ...B.key, ...g ? B.keyFunction : {} },
+          children: l
         },
-        c
+        l
       );
     }) })
   ] });
 }
-function Ge() {
-  const { t: e } = L(), [t, r] = P(z.create(2, 2)), [o, a] = P(z.create(2, 2)), [n, i] = P(""), c = (s, p, m, y, f) => {
-    const C = { ...s, data: s.data.map((x) => [...x]) };
-    C.data[m][y] = parseFloat(f) || 0, p(C);
-  }, u = [
-    { label: "A + B", fn: () => z.toString(z.add(t, o)) },
-    { label: "A - B", fn: () => z.toString(z.subtract(t, o)) },
-    { label: "A × B", fn: () => z.toString(z.multiply(t, o)) },
-    { label: "det(A)", fn: () => z.determinant(t).toFixed(4) },
-    { label: "Aᵀ", fn: () => z.toString(z.transpose(t)) },
-    { label: "A⁻¹", fn: () => z.toString(z.inverse(t)) }
+function Oe() {
+  const { t: e } = E(), [t, r] = M($.create(2, 2)), [o, a] = M($.create(2, 2)), [n, i] = M(""), l = (s, p, u, x, f) => {
+    const w = { ...s, data: s.data.map((y) => [...y]) };
+    w.data[u][x] = parseFloat(f) || 0, p(w);
+  }, g = [
+    { label: "A + B", fn: () => $.toString($.add(t, o)) },
+    { label: "A - B", fn: () => $.toString($.subtract(t, o)) },
+    { label: "A × B", fn: () => $.toString($.multiply(t, o)) },
+    // audit-allow: i18n — math notation
+    { label: "det(A)", fn: () => $.determinant(t).toFixed(4) },
+    // audit-allow: i18n — math notation
+    { label: "Aᵀ", fn: () => $.toString($.transpose(t)) },
+    { label: "A⁻¹", fn: () => $.toString($.inverse(t)) }
   ];
   return /* @__PURE__ */ v("div", { style: { padding: "12px", backgroundColor: "var(--nice-bg-secondary, #252525)" }, children: [
     /* @__PURE__ */ v("div", { style: { display: "flex", gap: "12px", marginBottom: "12px" }, children: [
@@ -2772,7 +3114,7 @@ function Ge() {
           re,
           {
             matrix: t,
-            onChange: (s, p, m) => c(t, r, s, p, m)
+            onChange: (s, p, u) => l(t, r, s, p, u)
           }
         )
       ] }),
@@ -2782,12 +3124,12 @@ function Ge() {
           re,
           {
             matrix: o,
-            onChange: (s, p, m) => c(o, a, s, p, m)
+            onChange: (s, p, u) => l(o, a, s, p, u)
           }
         )
       ] })
     ] }),
-    /* @__PURE__ */ d("div", { style: { display: "flex", gap: "4px", flexWrap: "wrap", marginBottom: "12px" }, children: u.map((s) => /* @__PURE__ */ d(
+    /* @__PURE__ */ d("div", { style: { display: "flex", gap: "4px", flexWrap: "wrap", marginBottom: "12px" }, children: g.map((s) => /* @__PURE__ */ d(
       "button",
       {
         onClick: () => {
@@ -2853,8 +3195,8 @@ function re({
     }
   );
 }
-function je() {
-  const { t: e } = L(), [t, r] = P("x^2"), [o, a] = P("");
+function Ge() {
+  const { t: e } = E(), [t, r] = M("x^2"), [o, a] = M("");
   return /* @__PURE__ */ v("div", { style: { padding: "12px", backgroundColor: "var(--nice-bg-secondary, #252525)" }, children: [
     /* @__PURE__ */ d(
       "input",
@@ -2921,24 +3263,24 @@ function je() {
     )
   ] });
 }
-function Fe() {
-  const { t: e } = L(), { service: t } = N(), [r, o] = P("1"), [a, n] = P("m"), [i, c] = P("ft"), [u, s] = P("Length"), [p, m] = P(""), y = t.getUnitCategories(), f = t.getUnitsByCategory(u), C = () => {
+function Ue() {
+  const { t: e } = E(), { service: t } = X(), [r, o] = M("1"), [a, n] = M("m"), [i, l] = M("ft"), [g, s] = M("Length"), [p, u] = M(""), x = t.getUnitCategories(), f = t.getUnitsByCategory(g), w = () => {
     try {
-      const x = t.convertUnits(parseFloat(r), a, i);
-      m(`${r} ${a} = ${t.format(x)} ${i}`);
-    } catch (x) {
-      m(x.message);
+      const y = t.convertUnits(parseFloat(r), a, i);
+      u(`${r} ${a} = ${t.format(y)} ${i}`);
+    } catch (y) {
+      u(y.message);
     }
   };
   return /* @__PURE__ */ v("div", { style: { padding: "12px", backgroundColor: "var(--nice-bg-secondary, #252525)" }, children: [
     /* @__PURE__ */ d(
       "select",
       {
-        value: u,
-        onChange: (x) => {
-          s(x.target.value);
-          const b = t.getUnitsByCategory(x.target.value);
-          b.length >= 2 && (n(b[0].symbol), c(b[1].symbol));
+        value: g,
+        onChange: (y) => {
+          s(y.target.value);
+          const b = t.getUnitsByCategory(y.target.value);
+          b.length >= 2 && (n(b[0].symbol), l(b[1].symbol));
         },
         style: {
           width: "100%",
@@ -2949,7 +3291,7 @@ function Fe() {
           border: "1px solid var(--nice-border-color, #555)",
           borderRadius: "4px"
         },
-        children: y.map((x) => /* @__PURE__ */ d("option", { value: x, children: x }, x))
+        children: x.map((y) => /* @__PURE__ */ d("option", { value: y, children: y }, y))
       }
     ),
     /* @__PURE__ */ v("div", { style: { display: "flex", gap: "8px", alignItems: "center", marginBottom: "12px" }, children: [
@@ -2958,7 +3300,7 @@ function Fe() {
         {
           type: "number",
           value: r,
-          onChange: (x) => o(x.target.value),
+          onChange: (y) => o(y.target.value),
           style: {
             flex: 1,
             padding: "8px",
@@ -2973,7 +3315,7 @@ function Fe() {
         "select",
         {
           value: a,
-          onChange: (x) => n(x.target.value),
+          onChange: (y) => n(y.target.value),
           style: {
             padding: "8px",
             backgroundColor: "var(--nice-border, #3c3c3c)",
@@ -2981,22 +3323,22 @@ function Fe() {
             border: "1px solid var(--nice-border-color, #555)",
             borderRadius: "4px"
           },
-          children: f.map((x) => /* @__PURE__ */ v("option", { value: x.symbol, children: [
-            x.name,
+          children: f.map((y) => /* @__PURE__ */ v("option", { value: y.symbol, children: [
+            y.name,
             " (",
-            x.symbol,
+            y.symbol,
             ")"
-          ] }, x.symbol))
+          ] }, y.symbol))
         }
       )
     ] }),
     /* @__PURE__ */ v("div", { style: { display: "flex", gap: "8px", alignItems: "center", marginBottom: "12px" }, children: [
-      /* @__PURE__ */ d("span", { style: { color: "var(--nice-text-secondary, #888)" }, children: /* @__PURE__ */ d(G, { name: "arrow-right", size: 12 }) }),
+      /* @__PURE__ */ d("span", { style: { color: "var(--nice-text-secondary, #888)" }, children: /* @__PURE__ */ d(j, { name: "arrow-right", size: 12 }) }),
       /* @__PURE__ */ d(
         "select",
         {
           value: i,
-          onChange: (x) => c(x.target.value),
+          onChange: (y) => l(y.target.value),
           style: {
             flex: 1,
             padding: "8px",
@@ -3005,19 +3347,19 @@ function Fe() {
             border: "1px solid var(--nice-border-color, #555)",
             borderRadius: "4px"
           },
-          children: f.map((x) => /* @__PURE__ */ v("option", { value: x.symbol, children: [
-            x.name,
+          children: f.map((y) => /* @__PURE__ */ v("option", { value: y.symbol, children: [
+            y.name,
             " (",
-            x.symbol,
+            y.symbol,
             ")"
-          ] }, x.symbol))
+          ] }, y.symbol))
         }
       )
     ] }),
     /* @__PURE__ */ d(
       "button",
       {
-        onClick: C,
+        onClick: w,
         style: {
           width: "100%",
           padding: "12px",
@@ -3045,7 +3387,7 @@ function Fe() {
     )
   ] });
 }
-const E = {
+const I = {
   /** Distance between two points */
   distance(e, t) {
     return Math.sqrt((t.x - e.x) ** 2 + (t.y - e.y) ** 2);
@@ -3082,21 +3424,21 @@ const E = {
   },
   /** Circle-line intersection */
   circleLineIntersection(e, t, r, o) {
-    const a = o.x - r.x, n = o.y - r.y, i = r.x - e.x, c = r.y - e.y, u = a * a + n * n, s = 2 * (i * a + c * n), p = i * i + c * c - t * t, m = s * s - 4 * u * p;
-    if (m < 0)
+    const a = o.x - r.x, n = o.y - r.y, i = r.x - e.x, l = r.y - e.y, g = a * a + n * n, s = 2 * (i * a + l * n), p = i * i + l * l - t * t, u = s * s - 4 * g * p;
+    if (u < 0)
       return [];
-    const y = Math.sqrt(m), f = (-s - y) / (2 * u), C = (-s + y) / (2 * u), x = [];
-    return f >= 0 && f <= 1 && x.push({ x: r.x + f * a, y: r.y + f * n }), C >= 0 && C <= 1 && Math.abs(C - f) > 1e-10 && x.push({ x: r.x + C * a, y: r.y + C * n }), x;
+    const x = Math.sqrt(u), f = (-s - x) / (2 * g), w = (-s + x) / (2 * g), y = [];
+    return f >= 0 && f <= 1 && y.push({ x: r.x + f * a, y: r.y + f * n }), w >= 0 && w <= 1 && Math.abs(w - f) > 1e-10 && y.push({ x: r.x + w * a, y: r.y + w * n }), y;
   },
   /** Circle-circle intersection */
   circleCircleIntersection(e, t, r, o) {
     const a = this.distance(e, r);
     if (a > t + o || a < Math.abs(t - o) || a === 0)
       return [];
-    const n = (t * t - o * o + a * a) / (2 * a), i = Math.sqrt(t * t - n * n), c = e.x + n * (r.x - e.x) / a, u = e.y + n * (r.y - e.y) / a;
+    const n = (t * t - o * o + a * a) / (2 * a), i = Math.sqrt(t * t - n * n), l = e.x + n * (r.x - e.x) / a, g = e.y + n * (r.y - e.y) / a;
     return [
-      { x: c + i * (r.y - e.y) / a, y: u - i * (r.x - e.x) / a },
-      { x: c - i * (r.y - e.y) / a, y: u + i * (r.x - e.x) / a }
+      { x: l + i * (r.y - e.y) / a, y: g - i * (r.x - e.x) / a },
+      { x: l - i * (r.y - e.y) / a, y: g + i * (r.x - e.x) / a }
     ];
   },
   /** Perpendicular line through point */
@@ -3193,10 +3535,10 @@ const E = {
     };
   }
 };
-class Oe {
+class Ye {
   constructor() {
-    T(this, "elements", /* @__PURE__ */ new Map());
-    T(this, "nextLabel", 1);
+    z(this, "elements", /* @__PURE__ */ new Map());
+    z(this, "nextLabel", 1);
   }
   /** Add element */
   addElement(t) {
@@ -3330,7 +3672,7 @@ class Oe {
     const o = this.getPoint(t), a = this.getPoint(r);
     if (!o || !a)
       return null;
-    const n = E.midpoint(o, a), i = this.createPoint(n.x, n.y);
+    const n = I.midpoint(o, a), i = this.createPoint(n.x, n.y);
     return i.dependencies = [t, r], i.color = { r: 0, g: 150, b: 0 }, i;
   }
   /** Create perpendicular */
@@ -3338,7 +3680,7 @@ class Oe {
     const a = this.getPoint(t), n = this.getPoint(r), i = this.getPoint(o);
     if (!a || !n || !i)
       return null;
-    const c = E.perpendicularThrough(a, n, i), u = this.createPoint(c.p2.x, c.p2.y), s = this.createLine(o, u.id);
+    const l = I.perpendicularThrough(a, n, i), g = this.createPoint(l.p2.x, l.p2.y), s = this.createLine(o, g.id);
     return s.dependencies = [t, r, o], s;
   }
   /** Create parallel */
@@ -3346,7 +3688,7 @@ class Oe {
     const a = this.getPoint(t), n = this.getPoint(r), i = this.getPoint(o);
     if (!a || !n || !i)
       return null;
-    const c = E.parallelThrough(a, n, i), u = this.createPoint(c.p2.x, c.p2.y), s = this.createLine(o, u.id);
+    const l = I.parallelThrough(a, n, i), g = this.createPoint(l.p2.x, l.p2.y), s = this.createLine(o, g.id);
     return s.dependencies = [t, r, o], s;
   }
   /** Create intersection point */
@@ -3356,36 +3698,36 @@ class Oe {
       return [];
     const n = [], i = (s) => {
       if (s.type === "line" || s.type === "segment" || s.type === "ray") {
-        const p = s, m = this.getPoint(p.point1Id ?? p.originId), y = this.getPoint(p.point2Id ?? p.throughId);
-        if (m && y)
-          return [m, y];
+        const p = s, u = this.getPoint(p.point1Id ?? p.originId), x = this.getPoint(p.point2Id ?? p.throughId);
+        if (u && x)
+          return [u, x];
       }
       return null;
-    }, c = i(o), u = i(a);
-    if (c && u) {
-      const s = E.lineIntersection(c[0], c[1], u[0], u[1]);
+    }, l = i(o), g = i(a);
+    if (l && g) {
+      const s = I.lineIntersection(l[0], l[1], g[0], g[1]);
       if (s) {
         const p = this.createPoint(s.x, s.y);
         p.dependencies = [t, r], p.color = { r: 255, g: 0, b: 0 }, n.push(p);
       }
     }
-    if (o.type === "circle" && u) {
+    if (o.type === "circle" && g) {
       const s = o, p = this.getPoint(s.centerId);
       if (p) {
-        const m = E.circleLineIntersection(p, s.radius, u[0], u[1]);
-        for (const y of m) {
-          const f = this.createPoint(y.x, y.y);
+        const u = I.circleLineIntersection(p, s.radius, g[0], g[1]);
+        for (const x of u) {
+          const f = this.createPoint(x.x, x.y);
           f.dependencies = [t, r], f.color = { r: 255, g: 0, b: 0 }, n.push(f);
         }
       }
     }
     if (o.type === "circle" && a.type === "circle") {
-      const s = o, p = a, m = this.getPoint(s.centerId), y = this.getPoint(p.centerId);
-      if (m && y) {
-        const f = E.circleCircleIntersection(m, s.radius, y, p.radius);
-        for (const C of f) {
-          const x = this.createPoint(C.x, C.y);
-          x.dependencies = [t, r], x.color = { r: 255, g: 0, b: 0 }, n.push(x);
+      const s = o, p = a, u = this.getPoint(s.centerId), x = this.getPoint(p.centerId);
+      if (u && x) {
+        const f = I.circleCircleIntersection(u, s.radius, x, p.radius);
+        for (const w of f) {
+          const y = this.createPoint(w.x, w.y);
+          y.dependencies = [t, r], y.color = { r: 255, g: 0, b: 0 }, n.push(y);
         }
       }
     }
@@ -3397,13 +3739,13 @@ class Oe {
       case "distance": {
         const o = this.getPoint(r[0]), a = this.getPoint(r[1]);
         if (o && a)
-          return E.distance(o, a);
+          return I.distance(o, a);
         break;
       }
       case "angle": {
         const o = this.getPoint(r[0]), a = this.getPoint(r[1]), n = this.getPoint(r[2]);
         if (o && a && n)
-          return E.angleDegrees(o, a, n);
+          return I.angleDegrees(o, a, n);
         break;
       }
       case "area":
@@ -3411,7 +3753,7 @@ class Oe {
         const o = this.elements.get(r[0]);
         if ((o == null ? void 0 : o.type) === "polygon") {
           const a = o.pointIds.map((n) => this.getPoint(n)).filter(Boolean);
-          return t === "area" ? E.polygonArea(a) : E.polygonPerimeter(a);
+          return t === "area" ? I.polygonArea(a) : I.polygonPerimeter(a);
         }
         break;
       }
@@ -3426,19 +3768,19 @@ class Oe {
     a.push(
       `<rect width="100%" height="100%" fill="rgb(${o.backgroundColor.r},${o.backgroundColor.g},${o.backgroundColor.b})"/>`
     );
-    const n = (i, c) => ({
+    const n = (i, l) => ({
       x: t / 2 + (i - o.centerX) * o.scale,
-      y: r / 2 - (c - o.centerY) * o.scale
+      y: r / 2 - (l - o.centerY) * o.scale
     });
     if (o.showGrid) {
       a.push('<g stroke="var(--nice-border, #ddd)" stroke-width="0.5">');
       for (let i = Math.floor(-t / 2 / o.scale + o.centerX); i <= t / 2 / o.scale + o.centerX; i += o.gridSpacing) {
-        const c = n(i, 0);
-        a.push(`<line x1="${c.x}" y1="0" x2="${c.x}" y2="${r}"/>`);
+        const l = n(i, 0);
+        a.push(`<line x1="${l.x}" y1="0" x2="${l.x}" y2="${r}"/>`);
       }
       for (let i = Math.floor(-r / 2 / o.scale + o.centerY); i <= r / 2 / o.scale + o.centerY; i += o.gridSpacing) {
-        const c = n(0, i);
-        a.push(`<line x1="0" y1="${c.y}" x2="${t}" y2="${c.y}"/>`);
+        const l = n(0, i);
+        a.push(`<line x1="0" y1="${l.y}" x2="${t}" y2="${l.y}"/>`);
       }
       a.push("</g>");
     }
@@ -3449,39 +3791,39 @@ class Oe {
     for (const i of this.getAllElements()) {
       if (!i.visible)
         continue;
-      const c = `rgb(${i.color.r},${i.color.g},${i.color.b})`;
+      const l = `rgb(${i.color.r},${i.color.g},${i.color.b})`;
       switch (i.type) {
         case "point": {
-          const u = n(i.x, i.y);
-          a.push(`<circle cx="${u.x}" cy="${u.y}" r="${i.size}" fill="${c}"/>`), i.label && a.push(`<text x="${u.x + 8}" y="${u.y - 8}" font-size="12">${i.label}</text>`);
+          const g = n(i.x, i.y);
+          a.push(`<circle cx="${g.x}" cy="${g.y}" r="${i.size}" fill="${l}"/>`), i.label && a.push(`<text x="${g.x + 8}" y="${g.y - 8}" font-size="12">${i.label}</text>`);
           break;
         }
         case "segment": {
-          const u = this.getPoint(i.point1Id), s = this.getPoint(i.point2Id);
-          if (u && s) {
-            const p = n(u.x, u.y), m = n(s.x, s.y);
+          const g = this.getPoint(i.point1Id), s = this.getPoint(i.point2Id);
+          if (g && s) {
+            const p = n(g.x, g.y), u = n(s.x, s.y);
             a.push(
-              `<line x1="${p.x}" y1="${p.y}" x2="${m.x}" y2="${m.y}" stroke="${c}" stroke-width="${i.width}"/>`
+              `<line x1="${p.x}" y1="${p.y}" x2="${u.x}" y2="${u.y}" stroke="${l}" stroke-width="${i.width}"/>`
             );
           }
           break;
         }
         case "circle": {
-          const u = this.getPoint(i.centerId);
-          if (u) {
-            const s = n(u.x, u.y), p = i.radius * o.scale, m = i.fill ? `rgba(${i.fill.r},${i.fill.g},${i.fill.b},${i.fill.a ?? 0.2})` : "none";
+          const g = this.getPoint(i.centerId);
+          if (g) {
+            const s = n(g.x, g.y), p = i.radius * o.scale, u = i.fill ? `rgba(${i.fill.r},${i.fill.g},${i.fill.b},${i.fill.a ?? 0.2})` : "none";
             a.push(
-              `<circle cx="${s.x}" cy="${s.y}" r="${p}" fill="${m}" stroke="${c}" stroke-width="${i.width}"/>`
+              `<circle cx="${s.x}" cy="${s.y}" r="${p}" fill="${u}" stroke="${l}" stroke-width="${i.width}"/>`
             );
           }
           break;
         }
         case "polygon": {
-          const u = i.pointIds.map((s) => this.getPoint(s)).filter(Boolean);
-          if (u.length > 0) {
-            const p = u.map((y) => n(y.x, y.y)).map((y, f) => `${f === 0 ? "M" : "L"}${y.x},${y.y}`).join(" ") + " Z", m = i.fill ? `rgba(${i.fill.r},${i.fill.g},${i.fill.b},${i.fill.a ?? 0.2})` : "none";
+          const g = i.pointIds.map((s) => this.getPoint(s)).filter(Boolean);
+          if (g.length > 0) {
+            const p = g.map((x) => n(x.x, x.y)).map((x, f) => `${f === 0 ? "M" : "L"}${x.x},${x.y}`).join(" ") + " Z", u = i.fill ? `rgba(${i.fill.r},${i.fill.g},${i.fill.b},${i.fill.a ?? 0.2})` : "none";
             a.push(
-              `<path d="${p}" fill="${m}" stroke="${c}" stroke-width="${i.width}"/>`
+              `<path d="${p}" fill="${u}" stroke="${l}" stroke-width="${i.width}"/>`
             );
           }
           break;
@@ -3499,12 +3841,12 @@ class Oe {
     return this.nextLabel++, r < 26 ? t[r] : t[r % 26] + Math.floor(r / 26);
   }
 }
-function nt() {
-  return new Oe();
+function st() {
+  return new Ye();
 }
-const de = /* @__PURE__ */ F(null);
+const ge = /* @__PURE__ */ O(null);
 function H() {
-  const e = j(de);
+  const e = F(ge);
   if (!e)
     throw new Error("useGeometry must be used within GeometryProvider");
   return e;
@@ -3558,14 +3900,14 @@ const q = {
     color: "var(--nice-text-secondary, #666)"
   }
 };
-function it({
+function lt({
   service: e,
   width: t = 800,
   height: r = 600,
   className: o,
   style: a
 }) {
-  const [n, i] = P([]), [c, u] = P("point"), [s, p] = P([]), [m, y] = P({
+  const [n, i] = M([]), [l, g] = M("point"), [s, p] = M([]), [u, x] = M({
     centerX: 0,
     centerY: 0,
     scale: 40,
@@ -3577,119 +3919,134 @@ function it({
     backgroundColor: { r: 255, g: 255, b: 255 }
   }), f = R(() => {
     i(e.getAllElements());
-  }, [e]), C = R((b) => {
-    y((l) => ({ ...l, ...b }));
+  }, [e]), w = R((b) => {
+    x((c) => ({ ...c, ...b }));
   }, []);
-  V(() => {
+  Y(() => {
     f();
   }, [f]);
-  const x = {
+  const y = {
     service: e,
     elements: n,
-    tool: c,
-    setTool: u,
-    view: m,
-    setView: C,
+    tool: l,
+    setTool: g,
+    view: u,
+    setView: w,
     selectedIds: s,
     setSelectedIds: p,
     refresh: f
   };
-  return /* @__PURE__ */ d(de.Provider, { value: x, children: /* @__PURE__ */ v("div", { className: o, style: { ...q.container, ...a }, children: [
-    /* @__PURE__ */ d(Ue, {}),
+  return /* @__PURE__ */ d(ge.Provider, { value: y, children: /* @__PURE__ */ v("div", { className: o, style: { ...q.container, ...a }, children: [
+    /* @__PURE__ */ d(Ve, {}),
     /* @__PURE__ */ v("div", { style: q.main, children: [
-      /* @__PURE__ */ d(Ve, { width: t, height: r }),
-      /* @__PURE__ */ d(Ye, { width: t, height: r })
+      /* @__PURE__ */ d(Ke, { width: t, height: r }),
+      /* @__PURE__ */ d(We, { width: t, height: r })
     ] })
   ] }) });
 }
-function Ue() {
-  const { tool: e, setTool: t } = H(), r = [
-    { id: "select", icon: "cursor", title: "Select" },
-    { id: "point", icon: "•", title: "Point" },
-    { id: "segment", icon: "—", title: "Segment" },
-    { id: "line", icon: "line", title: "Line" },
-    { id: "ray", icon: "arrow-right", title: "Ray" },
-    { id: "circle", icon: "circle", title: "Circle" },
-    { id: "polygon", icon: "triangle", title: "Polygon" },
-    { id: "perpendicular", icon: "⊥", title: "Perpendicular" },
-    { id: "parallel", icon: "∥", title: "Parallel" },
-    { id: "midpoint", icon: "⊙", title: "Midpoint" },
-    { id: "bisector", icon: "∠", title: "Angle Bisector" },
-    { id: "intersection", icon: "close", title: "Intersection" },
-    { id: "reflect", icon: "shuffle", title: "Reflect" },
-    { id: "rotate", icon: "refresh", title: "Rotate" },
-    { id: "measure", icon: "ruler", title: "Measure" }
+function Ve() {
+  const { t: e } = E(), { tool: t, setTool: r } = H(), o = [
+    { id: "select", icon: "cursor", title: e("geometry.select", "Select") },
+    { id: "point", icon: "point", title: e("geometry.point", "Point") },
+    { id: "segment", icon: "segment", title: e("geometry.segment", "Segment") },
+    { id: "line", icon: "line", title: e("geometry.line", "Line") },
+    { id: "ray", icon: "arrow-right", title: e("geometry.ray", "Ray") },
+    { id: "circle", icon: "circle", title: e("geometry.circle", "Circle") },
+    { id: "polygon", icon: "triangle", title: e("geometry.polygon", "Polygon") },
+    {
+      id: "perpendicular",
+      icon: "perpendicular",
+      title: e("geometry.perpendicular", "Perpendicular")
+    },
+    { id: "parallel", icon: "parallel", title: e("geometry.parallel", "Parallel") },
+    { id: "midpoint", icon: "midpoint", title: e("geometry.midpoint", "Midpoint") },
+    {
+      id: "bisector",
+      icon: "angle-bisector",
+      title: e("geometry.angleBisector", "Angle Bisector")
+    },
+    { id: "intersection", icon: "close", title: e("geometry.intersection", "Intersection") },
+    { id: "reflect", icon: "shuffle", title: e("geometry.reflect", "Reflect") },
+    { id: "rotate", icon: "refresh", title: e("geometry.rotate", "Rotate") },
+    { id: "measure", icon: "ruler", title: e("geometry.measure", "Measure") }
   ];
-  return /* @__PURE__ */ d("div", { style: q.toolbar, children: r.map((o) => /* @__PURE__ */ d(
+  return /* @__PURE__ */ d("div", { style: q.toolbar, children: o.map((a) => /* @__PURE__ */ d(
     "button",
     {
-      onClick: () => t(o.id),
-      title: o.title,
+      onClick: () => r(a.id),
+      title: a.title,
       style: {
         ...q.toolButton,
-        backgroundColor: e === o.id ? "var(--nice-primary-hover, #1976d2)" : "transparent",
-        color: e === o.id ? "var(--nice-color-white, #fff)" : "var(--nice-text, #333)"
+        backgroundColor: t === a.id ? "var(--nice-primary-hover, #1976d2)" : "transparent",
+        color: t === a.id ? "var(--nice-color-white, #fff)" : "var(--nice-text, #333)"
       },
-      children: /^[a-z][a-z0-9-]*$/.test(o.icon) ? /* @__PURE__ */ d(G, { name: o.icon, size: 16 }) : o.icon
+      children: /* @__PURE__ */ d(j, { name: a.icon, size: 16 })
     },
-    o.id
+    a.id
   )) });
 }
-function Ve({ width: e, height: t }) {
-  const r = U(null), { service: o, elements: a, tool: n, view: i, selectedIds: c, setSelectedIds: u, refresh: s } = H(), [p, m] = P([]), y = R(
-    (b, l) => {
-      const g = (b - e / 2) / i.scale + i.centerX, w = -(l - t / 2) / i.scale + i.centerY;
+function Ke({ width: e, height: t }) {
+  const r = U(null), { service: o, elements: a, tool: n, view: i, selectedIds: l, setSelectedIds: g, refresh: s } = H(), [p, u] = M([]), x = R(
+    (b, c) => {
+      const m = (b - e / 2) / i.scale + i.centerX, k = -(c - t / 2) / i.scale + i.centerY;
       return i.snapToGrid ? {
-        x: Math.round(g / i.gridSpacing) * i.gridSpacing,
-        y: Math.round(w / i.gridSpacing) * i.gridSpacing
-      } : { x: g, y: w };
+        x: Math.round(m / i.gridSpacing) * i.gridSpacing,
+        y: Math.round(k / i.gridSpacing) * i.gridSpacing
+      } : { x: m, y: k };
     },
     [e, t, i]
   ), f = R(
-    (b, l) => ({
+    (b, c) => ({
       x: e / 2 + (b - i.centerX) * i.scale,
-      y: t / 2 - (l - i.centerY) * i.scale
+      y: t / 2 - (c - i.centerY) * i.scale
     }),
     [e, t, i]
-  ), C = R(
+  ), w = R(
     (b) => {
-      var w;
-      const l = (w = r.current) == null ? void 0 : w.getBoundingClientRect();
-      if (!l)
+      for (const m of a)
+        if (m.type === "point" && I.distance(m, b) < 0.5)
+          return m;
+    },
+    [a]
+  ), y = R(
+    (b) => {
+      var k;
+      const c = (k = r.current) == null ? void 0 : k.getBoundingClientRect();
+      if (!c)
         return;
-      const g = y(b.clientX - l.left, b.clientY - l.top);
+      const m = x(b.clientX - c.left, b.clientY - c.top);
       switch (n) {
         case "point": {
-          o.createPoint(g.x, g.y), s();
+          o.createPoint(m.x, m.y), s();
           break;
         }
         case "segment":
         case "line":
         case "ray": {
-          const M = x(g);
-          if (M)
-            m((h) => {
-              const k = [...h, M.id];
-              return k.length === 2 ? (n === "segment" ? o.createSegment(k[0], k[1]) : n === "line" ? o.createLine(k[0], k[1]) : n === "ray" && o.createRay(k[0], k[1]), s(), []) : k;
+          const C = w(m);
+          if (C)
+            u((h) => {
+              const P = [...h, C.id];
+              return P.length === 2 ? (n === "segment" ? o.createSegment(P[0], P[1]) : n === "line" ? o.createLine(P[0], P[1]) : n === "ray" && o.createRay(P[0], P[1]), s(), []) : P;
             });
           else {
-            const h = o.createPoint(g.x, g.y);
-            m((k) => {
-              const S = [...k, h.id];
+            const h = o.createPoint(m.x, m.y);
+            u((P) => {
+              const S = [...P, h.id];
               return S.length === 2 ? (n === "segment" ? o.createSegment(S[0], S[1]) : n === "line" ? o.createLine(S[0], S[1]) : n === "ray" && o.createRay(S[0], S[1]), s(), []) : S;
             }), s();
           }
           break;
         }
         case "circle": {
-          const M = x(g);
-          if (M)
-            m((h) => {
+          const C = w(m);
+          if (C)
+            u((h) => {
               if (h.length === 0)
-                return [M.id];
-              const k = o.getPoint(h[0]);
-              if (k) {
-                const S = E.distance(k, g);
+                return [C.id];
+              const P = o.getPoint(h[0]);
+              if (P) {
+                const S = I.distance(P, m);
                 o.createCircle(h[0], S), s();
               }
               return [];
@@ -3697,202 +4054,188 @@ function Ve({ width: e, height: t }) {
           else if (p.length === 1) {
             const h = o.getPoint(p[0]);
             if (h) {
-              const k = E.distance(h, g);
-              o.createCircle(p[0], k), s(), m([]);
+              const P = I.distance(h, m);
+              o.createCircle(p[0], P), s(), u([]);
             }
           } else {
-            const h = o.createPoint(g.x, g.y);
-            m([h.id]), s();
+            const h = o.createPoint(m.x, m.y);
+            u([h.id]), s();
           }
           break;
         }
         case "midpoint": {
-          const M = x(g);
-          M && m((h) => {
-            const k = [...h, M.id];
-            return k.length === 2 ? (o.createMidpoint(k[0], k[1]), s(), []) : k;
+          const C = w(m);
+          C && u((h) => {
+            const P = [...h, C.id];
+            return P.length === 2 ? (o.createMidpoint(P[0], P[1]), s(), []) : P;
           });
           break;
         }
         case "select": {
-          const M = x(g);
-          u(M ? [M.id] : []);
+          const C = w(m);
+          g(C ? [C.id] : []);
           break;
         }
       }
     },
-    [n, o, s, y, p, u]
-  ), x = (b) => {
-    for (const g of a)
-      if (g.type === "point" && E.distance(g, b) < 0.5)
-        return g;
-  };
-  return V(() => {
-    const b = r.current, l = b == null ? void 0 : b.getContext("2d");
-    if (!(!b || !l)) {
-      if (l.fillStyle = `rgb(${i.backgroundColor.r},${i.backgroundColor.g},${i.backgroundColor.b})`, l.fillRect(0, 0, e, t), i.showGrid) {
-        l.strokeStyle = I("var(--nice-border, #e0e0e0)", l.canvas), l.lineWidth = 0.5;
-        const g = i.gridSpacing * i.scale, w = (e / 2 - i.centerX * i.scale) % g, M = (t / 2 + i.centerY * i.scale) % g;
-        for (let h = w; h < e; h += g)
-          l.beginPath(), l.moveTo(h, 0), l.lineTo(h, t), l.stroke();
-        for (let h = M; h < t; h += g)
-          l.beginPath(), l.moveTo(0, h), l.lineTo(e, h), l.stroke();
+    [n, o, s, x, p, g, w]
+  );
+  return Y(() => {
+    const b = r.current, c = b == null ? void 0 : b.getContext("2d");
+    if (!(!b || !c)) {
+      if (c.fillStyle = `rgb(${i.backgroundColor.r},${i.backgroundColor.g},${i.backgroundColor.b})`, c.fillRect(0, 0, e, t), i.showGrid) {
+        c.strokeStyle = D("var(--nice-border, #e0e0e0)", c.canvas), c.lineWidth = 0.5;
+        const m = i.gridSpacing * i.scale, k = (e / 2 - i.centerX * i.scale) % m, C = (t / 2 + i.centerY * i.scale) % m;
+        for (let h = k; h < e; h += m)
+          c.beginPath(), c.moveTo(h, 0), c.lineTo(h, t), c.stroke();
+        for (let h = C; h < t; h += m)
+          c.beginPath(), c.moveTo(0, h), c.lineTo(e, h), c.stroke();
       }
       if (i.showAxes) {
-        const g = f(0, 0);
-        l.strokeStyle = I("var(--nice-text, #333)", l.canvas), l.lineWidth = 1, l.beginPath(), l.moveTo(0, g.y), l.lineTo(e, g.y), l.stroke(), l.beginPath(), l.moveTo(g.x, 0), l.lineTo(g.x, t), l.stroke();
+        const m = f(0, 0);
+        c.strokeStyle = D("var(--nice-text, #333)", c.canvas), c.lineWidth = 1, c.beginPath(), c.moveTo(0, m.y), c.lineTo(e, m.y), c.stroke(), c.beginPath(), c.moveTo(m.x, 0), c.lineTo(m.x, t), c.stroke();
       }
-      for (const g of a) {
-        if (!g.visible)
+      for (const m of a) {
+        if (!m.visible)
           continue;
-        const w = `rgb(${g.color.r},${g.color.g},${g.color.b})`, M = c.includes(g.id);
-        switch (g.type) {
+        const k = `rgb(${m.color.r},${m.color.g},${m.color.b})`, C = l.includes(m.id);
+        switch (m.type) {
           case "point": {
-            const h = f(g.x, g.y);
-            l.beginPath(), l.arc(h.x, h.y, M ? g.size + 2 : g.size, 0, 2 * Math.PI), l.fillStyle = M ? I("var(--nice-primary-hover, #1976d2)", l.canvas) : w, l.fill(), g.label && (l.fillStyle = I("var(--nice-text, #333)", l.canvas), l.font = "12px sans-serif", l.fillText(g.label, h.x + 8, h.y - 8));
+            const h = f(m.x, m.y);
+            c.beginPath(), c.arc(h.x, h.y, C ? m.size + 2 : m.size, 0, 2 * Math.PI), c.fillStyle = C ? D("var(--nice-primary-hover, #1976d2)", c.canvas) : k, c.fill(), m.label && (c.fillStyle = D("var(--nice-text, #333)", c.canvas), c.font = "12px sans-serif", c.fillText(m.label, h.x + 8, h.y - 8));
             break;
           }
           case "segment": {
-            const h = o.getPoint(g.point1Id), k = o.getPoint(g.point2Id);
-            if (h && k) {
-              const S = f(h.x, h.y), D = f(k.x, k.y);
-              l.strokeStyle = w, l.lineWidth = g.width, l.beginPath(), l.moveTo(S.x, S.y), l.lineTo(D.x, D.y), l.stroke();
+            const h = o.getPoint(m.point1Id), P = o.getPoint(m.point2Id);
+            if (h && P) {
+              const S = f(h.x, h.y), L = f(P.x, P.y);
+              c.strokeStyle = k, c.lineWidth = m.width, c.beginPath(), c.moveTo(S.x, S.y), c.lineTo(L.x, L.y), c.stroke();
             }
             break;
           }
           case "line": {
-            const h = o.getPoint(g.point1Id), k = o.getPoint(g.point2Id);
-            if (h && k) {
-              const S = k.x - h.x, D = k.y - h.y, _ = -1e3, K = 1e3, Z = f(h.x + _ * S, h.y + _ * D), Q = f(h.x + K * S, h.y + K * D);
-              l.strokeStyle = w, l.lineWidth = g.width, l.beginPath(), l.moveTo(Z.x, Z.y), l.lineTo(Q.x, Q.y), l.stroke();
+            const h = o.getPoint(m.point1Id), P = o.getPoint(m.point2Id);
+            if (h && P) {
+              const S = P.x - h.x, L = P.y - h.y, _ = -1e3, Z = 1e3, J = f(h.x + _ * S, h.y + _ * L), Q = f(h.x + Z * S, h.y + Z * L);
+              c.strokeStyle = k, c.lineWidth = m.width, c.beginPath(), c.moveTo(J.x, J.y), c.lineTo(Q.x, Q.y), c.stroke();
             }
             break;
           }
           case "circle": {
-            const h = o.getPoint(g.centerId);
+            const h = o.getPoint(m.centerId);
             if (h) {
-              const k = f(h.x, h.y), S = g.radius * i.scale;
-              l.beginPath(), l.arc(k.x, k.y, S, 0, 2 * Math.PI), g.fill && (l.fillStyle = `rgba(${g.fill.r},${g.fill.g},${g.fill.b},${g.fill.a ?? 0.2})`, l.fill()), l.strokeStyle = w, l.lineWidth = g.width, l.stroke();
+              const P = f(h.x, h.y), S = m.radius * i.scale;
+              c.beginPath(), c.arc(P.x, P.y, S, 0, 2 * Math.PI), m.fill && (c.fillStyle = `rgba(${m.fill.r},${m.fill.g},${m.fill.b},${m.fill.a ?? 0.2})`, c.fill()), c.strokeStyle = k, c.lineWidth = m.width, c.stroke();
             }
             break;
           }
           case "polygon": {
-            const h = g.pointIds.map((k) => o.getPoint(k)).filter(Boolean);
+            const h = m.pointIds.map((P) => o.getPoint(P)).filter(Boolean);
             if (h.length > 0) {
-              l.beginPath();
-              const k = f(h[0].x, h[0].y);
-              l.moveTo(k.x, k.y);
+              c.beginPath();
+              const P = f(h[0].x, h[0].y);
+              c.moveTo(P.x, P.y);
               for (let S = 1; S < h.length; S++) {
-                const D = f(h[S].x, h[S].y);
-                l.lineTo(D.x, D.y);
+                const L = f(h[S].x, h[S].y);
+                c.lineTo(L.x, L.y);
               }
-              l.closePath(), g.fill && (l.fillStyle = `rgba(${g.fill.r},${g.fill.g},${g.fill.b},${g.fill.a ?? 0.2})`, l.fill()), l.strokeStyle = w, l.lineWidth = g.width, l.stroke();
+              c.closePath(), m.fill && (c.fillStyle = `rgba(${m.fill.r},${m.fill.g},${m.fill.b},${m.fill.a ?? 0.2})`, c.fill()), c.strokeStyle = k, c.lineWidth = m.width, c.stroke();
             }
             break;
           }
         }
       }
       if (p.length > 0) {
-        l.fillStyle = I(
+        c.fillStyle = D(
           "var(--nice-primary-tint-30, rgba(25, 118, 210, 0.3))",
-          l.canvas
+          c.canvas
         );
-        for (const g of p) {
-          const w = o.getPoint(g);
-          if (w) {
-            const M = f(w.x, w.y);
-            l.beginPath(), l.arc(M.x, M.y, 12, 0, 2 * Math.PI), l.fill();
+        for (const m of p) {
+          const k = o.getPoint(m);
+          if (k) {
+            const C = f(k.x, k.y);
+            c.beginPath(), c.arc(C.x, C.y, 12, 0, 2 * Math.PI), c.fill();
           }
         }
       }
     }
-  }, [a, i, e, t, c, p, o, f]), /* @__PURE__ */ d(
+  }, [a, i, e, t, l, p, o, f]), /* @__PURE__ */ d(
     "canvas",
     {
       ref: r,
       width: e,
       height: t,
       style: q.canvas,
-      onClick: C
+      onClick: y
     }
   );
 }
-function Ye({
+function We({
   width: e,
   height: t
 }) {
-  const { tool: r, elements: o, view: a, service: n } = H(), [i, c] = P(null), u = {
-    select: "Select",
-    point: "Point",
-    line: "Line",
-    ray: "Ray",
-    segment: "Segment",
-    circle: "Circle",
-    arc: "Arc",
-    polygon: "Polygon",
-    angle: "Angle",
-    perpendicular: "Perpendicular",
-    parallel: "Parallel",
-    bisector: "Angle Bisector",
-    midpoint: "Midpoint",
-    tangent: "Tangent",
-    intersection: "Intersection",
-    reflect: "Reflect",
-    rotate: "Rotate",
-    translate: "Translate",
-    dilate: "Dilate",
-    measure: "Measure",
-    text: "Text"
-  }, s = o.filter((p) => p.type === "point").length;
+  const { t: r } = E(), { tool: o, elements: a, view: n, service: i } = H(), [l, g] = M(null), s = {
+    select: r("geometry.select", "Select"),
+    point: r("geometry.point", "Point"),
+    line: r("geometry.line", "Line"),
+    ray: r("geometry.ray", "Ray"),
+    segment: r("geometry.segment", "Segment"),
+    circle: r("geometry.circle", "Circle"),
+    arc: r("geometry.arc", "Arc"),
+    polygon: r("geometry.polygon", "Polygon"),
+    angle: r("geometry.angle", "Angle"),
+    perpendicular: r("geometry.perpendicular", "Perpendicular"),
+    parallel: r("geometry.parallel", "Parallel"),
+    bisector: r("geometry.angleBisector", "Angle Bisector"),
+    midpoint: r("geometry.midpoint", "Midpoint"),
+    tangent: r("geometry.tangent", "Tangent"),
+    intersection: r("geometry.intersection", "Intersection"),
+    reflect: r("geometry.reflect", "Reflect"),
+    rotate: r("geometry.rotate", "Rotate"),
+    translate: r("geometry.translate", "Translate"),
+    dilate: r("geometry.dilate", "Dilate"),
+    measure: r("geometry.measure", "Measure"),
+    text: r("geometry.text", "Text")
+  }, p = a.filter((u) => u.type === "point").length;
   return /* @__PURE__ */ v("div", { style: q.statusBar, children: [
-    /* @__PURE__ */ v("span", { children: [
-      "Tool: ",
-      u[r]
-    ] }),
+    /* @__PURE__ */ d("span", { children: r("geometry.tool", "Tool: {tool}").replace("{tool}", String(s[o])) }),
     /* @__PURE__ */ d("span", { style: { margin: "0 16px" }, children: "|" }),
-    /* @__PURE__ */ v("span", { children: [
-      "Objects: ",
-      o.length
-    ] }),
+    /* @__PURE__ */ d("span", { children: r("geometry.objects", "Objects: {elements}").replace(
+      "{elements}",
+      String(a.length)
+    ) }),
     /* @__PURE__ */ d("span", { style: { margin: "0 16px" }, children: "|" }),
-    /* @__PURE__ */ v("span", { children: [
-      "Points: ",
-      s
-    ] }),
+    /* @__PURE__ */ d("span", { children: r("geometry.points", "Points: {pointCount}").replace("{pointCount}", String(p)) }),
     /* @__PURE__ */ d("span", { style: { margin: "0 16px" }, children: "|" }),
-    /* @__PURE__ */ v("span", { children: [
-      "Scale: ",
-      a.scale.toFixed(1),
-      "x"
-    ] })
+    /* @__PURE__ */ d("span", { children: r("geometry.scaleX", "Scale: {scale}x").replace("{scale}", String(n.scale.toFixed(1))) })
   ] });
 }
 export {
-  Le as CalculatorService,
+  qe as CalculatorService,
   te as CalculusOps,
-  we as EQUATION_TEMPLATES,
-  ie as ExpressionParser,
+  Pe as EQUATION_TEMPLATES,
+  le as ExpressionParser,
   ee as FUNCTION_PRESETS,
-  E as GeoMath,
-  Oe as GeometryService,
-  Te as GraphService,
-  be as MATH_SYMBOLS,
-  ke as MathEditorService,
-  z as MatrixOps,
-  at as NiceCalculator,
-  it as NiceGeometry,
-  rt as NiceGraphPlotter,
-  Qe as NiceI18nProvider,
-  et as NiceMathEditor,
-  ot as createCalculatorService,
-  nt as createGeometryService,
-  tt as createGraphService,
-  Je as createMathEditorService,
-  ve as getSymbolsByCategory,
+  I as GeoMath,
+  Ye as GeometryService,
+  $e as GraphService,
+  we as MATH_SYMBOLS,
+  Me as MathEditorService,
+  $ as MatrixOps,
+  it as NiceCalculator,
+  lt as NiceGeometry,
+  at as NiceGraphPlotter,
+  et as NiceI18nProvider,
+  rt as NiceMathEditor,
+  nt as createCalculatorService,
+  st as createGeometryService,
+  ot as createGraphService,
+  tt as createMathEditorService,
+  ke as getSymbolsByCategory,
   Ce as recognizeHandwriting,
-  N as useCalculator,
+  X as useCalculator,
   H as useGeometry,
-  Y as useGraph,
+  V as useGraph,
   W as useMathEditor,
-  L as useNiceTranslation
+  E as useNiceTranslation
 };