@pie-players/pie-calculator-cortex 0.3.68

package/dist/chunks/settings-C0zxv5EL.js

@@ -0,0 +1,389 @@
+var g = class extends Error {
+  code;
+  recoverable;
+  constructor(e, r, n = {}) {
+    super(r, n.cause === void 0 ? void 0 : { cause: n.cause }), this.name = "CortexCalculatorError", this.code = e, this.recoverable = n.recoverable ?? !0;
+  }
+};
+function N(e, r, n) {
+  return e instanceof g ? e : new g(r, n, {
+    cause: e,
+    recoverable: r !== "worker-unavailable"
+  });
+}
+var h = {
+  basicCalculator: "Basic calculator",
+  scientificCalculator: "Scientific calculator",
+  graphingCalculator: "Graphing calculator",
+  expressionLabel: "{calculator} expression",
+  angleMode: "Angle mode",
+  degrees: "Degrees",
+  radians: "Radians",
+  calculate: "Calculate",
+  calculating: "Calculating",
+  backspace: "Backspace",
+  clear: "Clear",
+  result: "Result: {result}",
+  calculationHistory: "Calculation history",
+  clearHistory: "Clear history",
+  virtualKeyboardBasic: "Basic",
+  virtualKeyboardScientific: "Scientific",
+  virtualKeyboardGraphing: "Graphing",
+  keypad: "Keypad",
+  keypadLayer: "Keypad layer",
+  angleModeDegreesShort: "DEG",
+  angleModeRadiansShort: "RAD",
+  angleModeChanged: "Angle mode {mode}. Previous result cleared.",
+  inserted: "{key}",
+  keySine: "sin, sine",
+  keyCosine: "cos, cosine",
+  keyTangent: "tan, tangent",
+  keyInverseSine: "sin, inverse sine",
+  keyInverseCosine: "cos, inverse cosine",
+  keyInverseTangent: "tan, inverse tangent",
+  keyNaturalLog: "ln, natural logarithm",
+  keyCommonLog: "log, common logarithm",
+  keyLogBaseN: "Logarithm with a chosen base",
+  keyFraction: "Fraction",
+  keySquareRoot: "Square root",
+  keyNthRoot: "Nth root",
+  keyPower: "To the power of",
+  keySquared: "Squared",
+  keyCubed: "Cubed",
+  keyExponential: "e to the power of",
+  keyAbsoluteValue: "Absolute value",
+  keyFactorial: "Factorial",
+  keyPi: "Pi",
+  keyEuler: "e, Euler's number",
+  keyPercent: "Percent",
+  keyOpenParenthesis: "Open parenthesis",
+  keyCloseParenthesis: "Close parenthesis",
+  keyDecimalSeparator: "Decimal separator",
+  keyDigit: "{digit}",
+  keyAdd: "Plus",
+  keySubtract: "Minus",
+  keyMultiply: "Times",
+  keyDivide: "Divided by",
+  keyVariableX: "x, variable x",
+  graphExpressions: "Graph expressions",
+  graphExpressionLabel: "Graph expression {index}, {lineStyle} line",
+  seriesDescription: "Series {index}: {lineStyle} line",
+  showExpression: "Show expression {index}",
+  hideExpression: "Hide expression {index}",
+  show: "Show",
+  hide: "Hide",
+  removeExpression: "Remove expression {index}",
+  remove: "Remove",
+  addExpression: "Add expression",
+  graph: "Graph",
+  viewportControls: "Graph view",
+  zoomIn: "Zoom in",
+  zoomOut: "Zoom out",
+  panLeft: "Pan left",
+  panRight: "Pan right",
+  panUp: "Pan up",
+  panDown: "Pan down",
+  resetView: "Reset view",
+  updatingGraph: "Updating graph",
+  graphSummary: "Graph summary",
+  viewportSummary: "Viewport x from {xMin} to {xMax}, y from {yMin} to {yMax}.",
+  seriesSummary: "Series {index}, {lineStyle}: {expression}",
+  keyboardGraphTrace: "Keyboard graph trace",
+  keyboardTrace: "Keyboard trace",
+  series: "Series",
+  seriesOption: "Series {index}",
+  previousPoint: "Previous point",
+  nextPoint: "Next point",
+  tracePoint: "x {x}, y {y}",
+  noSampledPoint: "No sampled graph point is available.",
+  lineStyleSolid: "solid",
+  lineStyleDashed: "dashed",
+  lineStyleDotted: "dotted",
+  errorInvalidExpression: "Check the expression and try again.",
+  errorUnsupportedExpression: "This expression is not available in this calculator.",
+  errorExpressionTooComplex: "Simplify the expression and try again.",
+  errorEvaluationTimeout: "The calculation took too long and was stopped.",
+  errorInvalidState: "The saved calculator state could not be restored.",
+  errorWorkerUnavailable: "The calculator is temporarily unavailable."
+}, m = {
+  basicCalculator: "Eenvoudige rekenmachine",
+  scientificCalculator: "Wetenschappelijke rekenmachine",
+  graphingCalculator: "Grafische rekenmachine",
+  expressionLabel: "Uitdrukking voor {calculator}",
+  angleMode: "Hoekeenheid",
+  degrees: "Graden",
+  radians: "Radialen",
+  calculate: "Bereken",
+  calculating: "Bezig met berekenen",
+  backspace: "Wis teken",
+  clear: "Wissen",
+  result: "Resultaat: {result}",
+  calculationHistory: "Berekeningsgeschiedenis",
+  clearHistory: "Geschiedenis wissen",
+  virtualKeyboardBasic: "Eenvoudig",
+  virtualKeyboardScientific: "Wetenschappelijk",
+  virtualKeyboardGraphing: "Grafisch",
+  keypad: "Toetsenblok",
+  keypadLayer: "Laag van het toetsenblok",
+  angleModeDegreesShort: "GR",
+  angleModeRadiansShort: "RAD",
+  angleModeChanged: "Hoekeenheid {mode}. Vorig resultaat gewist.",
+  inserted: "{key}",
+  keySine: "sin, sinus",
+  keyCosine: "cos, cosinus",
+  keyTangent: "tan, tangens",
+  keyInverseSine: "sin, arcsinus",
+  keyInverseCosine: "cos, arccosinus",
+  keyInverseTangent: "tan, arctangens",
+  keyNaturalLog: "ln, natuurlijke logaritme",
+  keyCommonLog: "log, logaritme met grondtal tien",
+  keyLogBaseN: "Logaritme met gekozen grondtal",
+  keyFraction: "Breuk",
+  keySquareRoot: "Vierkantswortel",
+  keyNthRoot: "N-de wortel",
+  keyPower: "Tot de macht",
+  keySquared: "Kwadraat",
+  keyCubed: "Derde macht",
+  keyExponential: "e tot de macht",
+  keyAbsoluteValue: "Absolute waarde",
+  keyFactorial: "Faculteit",
+  keyPi: "Pi",
+  keyEuler: "e, getal van Euler",
+  keyPercent: "Procent",
+  keyOpenParenthesis: "Haakje openen",
+  keyCloseParenthesis: "Haakje sluiten",
+  keyDecimalSeparator: "Decimaalteken",
+  keyDigit: "{digit}",
+  keyAdd: "Plus",
+  keySubtract: "Min",
+  keyMultiply: "Maal",
+  keyDivide: "Gedeeld door",
+  keyVariableX: "x, variabele x",
+  graphExpressions: "Grafiekuitdrukkingen",
+  graphExpressionLabel: "Grafiekuitdrukking {index}, {lineStyle} lijn",
+  seriesDescription: "Reeks {index}: {lineStyle} lijn",
+  showExpression: "Uitdrukking {index} tonen",
+  hideExpression: "Uitdrukking {index} verbergen",
+  show: "Tonen",
+  hide: "Verbergen",
+  removeExpression: "Uitdrukking {index} verwijderen",
+  remove: "Verwijderen",
+  addExpression: "Uitdrukking toevoegen",
+  graph: "Grafiek",
+  viewportControls: "Grafiekweergave",
+  zoomIn: "Inzoomen",
+  zoomOut: "Uitzoomen",
+  panLeft: "Naar links verschuiven",
+  panRight: "Naar rechts verschuiven",
+  panUp: "Naar boven verschuiven",
+  panDown: "Naar beneden verschuiven",
+  resetView: "Weergave herstellen",
+  updatingGraph: "Grafiek wordt bijgewerkt",
+  graphSummary: "Samenvatting van de grafiek",
+  viewportSummary: "Weergave x van {xMin} tot {xMax}, y van {yMin} tot {yMax}.",
+  seriesSummary: "Reeks {index}, {lineStyle}: {expression}",
+  keyboardGraphTrace: "Grafiek volgen met het toetsenbord",
+  keyboardTrace: "Volgen met het toetsenbord",
+  series: "Reeks",
+  seriesOption: "Reeks {index}",
+  previousPoint: "Vorig punt",
+  nextPoint: "Volgend punt",
+  tracePoint: "x {x}, y {y}",
+  noSampledPoint: "Er is geen bemonsterd grafiekpunt beschikbaar.",
+  lineStyleSolid: "ononderbroken",
+  lineStyleDashed: "gestreepte",
+  lineStyleDotted: "gestippelde",
+  errorInvalidExpression: "Controleer de uitdrukking en probeer het opnieuw.",
+  errorUnsupportedExpression: "Deze uitdrukking is niet beschikbaar in deze rekenmachine.",
+  errorExpressionTooComplex: "Vereenvoudig de uitdrukking en probeer het opnieuw.",
+  errorEvaluationTimeout: "De berekening duurde te lang en is gestopt.",
+  errorInvalidState: "De opgeslagen rekenmachinestatus kon niet worden hersteld.",
+  errorWorkerUnavailable: "De rekenmachine is tijdelijk niet beschikbaar."
+}, v = {
+  "invalid-expression": "errorInvalidExpression",
+  "unsupported-expression": "errorUnsupportedExpression",
+  "expression-too-complex": "errorExpressionTooComplex",
+  "evaluation-timeout": "errorEvaluationTimeout",
+  "invalid-state": "errorInvalidState",
+  "worker-unavailable": "errorWorkerUnavailable"
+}, x = {
+  solid: "lineStyleSolid",
+  dashed: "lineStyleDashed",
+  dotted: "lineStyleDotted"
+}, f = /* @__PURE__ */ new Set([
+  "ar",
+  "ckb",
+  "dv",
+  "fa",
+  "he",
+  "iw",
+  "ks",
+  "ku",
+  "nqo",
+  "ps",
+  "sd",
+  "syr",
+  "ug",
+  "ur",
+  "yi"
+]);
+function b(e) {
+  try {
+    return new Intl.Locale(e.replaceAll("_", "-")).language.toLowerCase();
+  } catch {
+    return e.replaceAll("_", "-").split("-")[0]?.toLowerCase() ?? "en";
+  }
+}
+function S(e) {
+  try {
+    return new Intl.NumberFormat(e).format(1.1).includes(",") ? "," : ".";
+  } catch {
+    return ".";
+  }
+}
+function w(e) {
+  try {
+    const r = new Intl.Locale(e.replaceAll("_", "-")).textInfo;
+    if (r?.direction === "rtl" || r?.direction === "ltr") return r.direction;
+  } catch {
+  }
+  return f.has(b(e)) ? "rtl" : "ltr";
+}
+function E(e) {
+  return b(e) === "nl" ? m : h;
+}
+function M(e, r) {
+  return e.replace(/\{([a-zA-Z][a-zA-Z0-9]*)\}/g, (n, t) => Object.hasOwn(r, t) ? String(r[t]) : n);
+}
+function C(e, r = {}, n = "auto") {
+  const t = Object.freeze({
+    ...E(e),
+    ...r
+  }), o = n === "auto" ? w(e) : n, s = S(e);
+  let u = null, c = 0;
+  const l = (i, d = {}) => M(t[i], d);
+  return Object.freeze({
+    locale: e,
+    direction: o,
+    messages: t,
+    t: l,
+    formatNumber(i, d = 6) {
+      try {
+        return (!u || c !== d) && (c = d, u = new Intl.NumberFormat(e, {
+          maximumSignificantDigits: d,
+          useGrouping: !1
+        })), u.format(i);
+      } catch {
+        return i.toPrecision(d);
+      }
+    },
+    formatResult(i) {
+      return s === "." ? i : i.replace(".", s);
+    },
+    errorMessage(i) {
+      return l(v[i]);
+    },
+    lineStyle(i) {
+      return l(x[i]);
+    }
+  });
+}
+var G = h, A = m, R = 1024, P = {
+  xMin: -10,
+  xMax: 10,
+  yMin: -10,
+  yMax: 10
+}, L = ["square-root"], k = [
+  "square-root",
+  "power",
+  "root",
+  "exponential",
+  "natural-log",
+  "common-log",
+  "log-base-n",
+  "sine",
+  "cosine",
+  "tangent",
+  "inverse-sine",
+  "inverse-cosine",
+  "inverse-tangent",
+  "absolute-value",
+  "factorial"
+];
+function a(e) {
+  throw new g("invalid-state", e);
+}
+function p(e, r, n, t, o) {
+  return e === void 0 ? r : ((!Number.isInteger(e) || e < n || e > t) && a(`${o} must be an integer from ${n} to ${t}.`), e);
+}
+function T(e) {
+  if (e === void 0) return { ...P };
+  (!e || typeof e != "object") && a("Graph viewport must be an object.");
+  const r = e;
+  return [
+    r.xMin,
+    r.xMax,
+    r.yMin,
+    r.yMax
+  ].every((n) => typeof n == "number" && Number.isFinite(n)) || a("Graph viewport bounds must be finite numbers."), (r.xMin >= r.xMax || r.yMin >= r.yMax) && a("Graph viewport minimums must be less than maximums."), r;
+}
+function D(e, r) {
+  const n = e === "basic" ? L : k;
+  if (r === void 0) return new Set(n);
+  (!Array.isArray(r) || !r.every((s) => typeof s == "string")) && a("allowedFunctions must be an array of function identifiers.");
+  const t = new Set(k);
+  for (const s of r) t.has(s) || a(`Unknown calculator function: ${s}.`);
+  const o = new Set(r);
+  return new Set(n.filter((s) => o.has(s)));
+}
+function y(e, r, n) {
+  return e === void 0 ? r : (typeof e != "boolean" && a(`${n} must be a boolean.`), e);
+}
+function I(e) {
+  if (e === void 0) return {};
+  (!e || typeof e != "object" || Array.isArray(e)) && a("messages must be an object.");
+  const r = {};
+  for (const [n, t] of Object.entries(e))
+    Object.hasOwn(G, n) && (typeof t != "string" && a(`messages.${n} must be a string.`), r[n] = t);
+  return r;
+}
+function j(e, r = {}) {
+  const n = r.settings ?? {}, t = n.angleMode ?? "degree";
+  t !== "degree" && t !== "radian" && a('angleMode must be "degree" or "radian".');
+  const o = n.graph;
+  o !== void 0 && (!o || typeof o != "object") && a("graph settings must be an object.");
+  const s = r.restrictedMode === !0, u = typeof r.locale == "string" && r.locale.trim() ? r.locale.trim() : "en-US", c = r.theme ?? "auto";
+  c !== "light" && c !== "dark" && c !== "auto" && a('theme must be "light", "dark", or "auto".');
+  const l = n.direction ?? "auto";
+  l !== "ltr" && l !== "rtl" && l !== "auto" && a('direction must be "ltr", "rtl", or "auto".');
+  const i = C(u, I(n.messages), l);
+  return Object.freeze({
+    type: e,
+    angleMode: t,
+    calculationPrecision: p(n.calculationPrecision, 15, 1, 21, "calculationPrecision"),
+    displayPrecision: p(n.displayPrecision, 10, 1, 12, "displayPrecision"),
+    historyLimit: p(n.historyLimit, 20, 0, 50, "historyLimit"),
+    evaluationTimeLimitMs: p(n.evaluationTimeLimitMs, 1e3, 100, 2e3, "evaluationTimeLimitMs"),
+    allowedFunctions: D(e, n.allowedFunctions),
+    allowClipboard: !s && y(n.allowClipboard, !0, "allowClipboard"),
+    restrictedMode: s,
+    locale: u,
+    theme: c,
+    localization: i,
+    graph: Object.freeze({
+      viewport: T(o?.viewport),
+      showAxes: y(o?.showAxes, !0, "graph.showAxes"),
+      showGrid: y(o?.showGrid, !0, "graph.showGrid")
+    })
+  });
+}
+export {
+  S as a,
+  N as c,
+  G as i,
+  j as n,
+  w as o,
+  A as r,
+  g as s,
+  R as t
+};