@fluixi/utils 1.0.0-alpha.100

package/dist/lib/maths/fn/basic.mjs

@@ -0,0 +1,191 @@
+// src/lib/maths/fn/basic.ts
+function add(a, b) {
+  return a + b;
+}
+function subtract(a, b) {
+  return a - b;
+}
+var divide = (dividend, divisor, fallback) => {
+  if (divisor === 0) {
+    return fallback !== void 0 ? fallback : NaN;
+  }
+  return dividend / divisor;
+};
+function modulo(a, b) {
+  return a % b;
+}
+function power(base, exponent) {
+  return Math.pow(base, exponent);
+}
+function sqrt(value) {
+  if (value < 0) {
+    throw new Error("Cannot calculate square root of negative number");
+  }
+  return Math.sqrt(value);
+}
+function abs(value) {
+  return Math.abs(value);
+}
+var round = (value, precision = 0, mode = "round") => {
+  if (mode === "david") return roundUsingDavidGay(value, precision, mode);
+  if (!Number.isFinite(value)) return value;
+  if (precision === 0) return Math[mode](value);
+  if (precision < 0) {
+    const factor2 = 10 ** -precision;
+    return Math[mode](value / factor2) * factor2;
+  }
+  const factor = 10 ** precision;
+  const epsilon = Math.pow(2, -52);
+  const adjusted = value * factor;
+  const correction = Math.sign(adjusted) * epsilon * Math.abs(adjusted);
+  let rounded;
+  switch (mode) {
+    case "round":
+      rounded = Math.round(adjusted + correction);
+      break;
+    case "ceil":
+      rounded = Math.ceil(adjusted - epsilon);
+      break;
+    case "floor":
+      rounded = Math.floor(adjusted + epsilon);
+      break;
+    case "trunc":
+      rounded = adjusted < 0 ? Math.ceil(adjusted) : Math.floor(adjusted);
+      break;
+    default:
+      rounded = Math.round(adjusted + correction);
+  }
+  return rounded / factor;
+};
+var roundUsingDavidGay = (_value, precision = 0, mode = "round") => {
+  let value = Math.abs(_value);
+  const multiplicator = _value < 0 ? -1 : 1;
+  if (precision === 0) {
+    return Math.round(value) * multiplicator;
+  }
+  if (!Number.isFinite(value)) {
+    return value * multiplicator;
+  }
+  const factor = 10 ** precision;
+  let shifted = value * factor;
+  const epsilon = Math.pow(2, -53);
+  const correction = Math.sign(shifted) * epsilon * Math.abs(shifted);
+  shifted += correction;
+  const rounded = Math.round(shifted);
+  return rounded / factor * multiplicator;
+};
+var ceil = (value, precision = 0) => {
+  return round(value, precision, "ceil");
+};
+var floor = (value, precision = 0) => {
+  return round(value, precision, "floor");
+};
+var trunc = (value, precision = 0) => {
+  return round(value, precision, "trunc");
+};
+var clamp = (value, min2, max2) => {
+  if (min2 > max2) [min2, max2] = [max2, min2];
+  return value < min2 ? min2 : value > max2 ? max2 : value;
+};
+function sign(value) {
+  if (value > 0) return 1;
+  if (value < 0) return -1;
+  return 0;
+}
+function factorial(n) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new Error("Factorial is only defined for non-negative integers");
+  }
+  if (n === 0 || n === 1) return 1;
+  let result = 1;
+  for (let i = 2; i <= n; i++) {
+    result *= i;
+  }
+  return result;
+}
+function gcd(a, b) {
+  a = Math.abs(a);
+  b = Math.abs(b);
+  while (b !== 0) {
+    const temp = b;
+    b = a % b;
+    a = temp;
+  }
+  return a;
+}
+function lcm(a, b) {
+  return Math.abs(a * b) / gcd(a, b);
+}
+function lerp(start, end, t) {
+  return start + (end - start) * clamp(t, 0, 1);
+}
+var invLerp = (start, end, value) => {
+  return clamp((value - start) / (end - start), 0, 1);
+};
+var mapRange = (value, inMin, inMax, outMin, outMax) => {
+  const t = invLerp(inMin, inMax, value);
+  return lerp(outMin, outMax, t);
+};
+function min(...values) {
+  return Math.min(...values);
+}
+function max(...values) {
+  return Math.max(...values);
+}
+var average = (...numbers) => {
+  if (!Array.isArray(numbers) || numbers.length === 0) return 0;
+  let total = 0;
+  let count = 0;
+  for (const num of numbers) {
+    if (Number.isFinite(num)) {
+      total += num;
+      count++;
+    }
+  }
+  return count === 0 ? 0 : total / count;
+};
+var sum = (...numbers) => {
+  if (!Array.isArray(numbers)) return 0;
+  return numbers.reduce(
+    (acc, val) => acc + (Number.isFinite(val) ? val : 0),
+    0
+  );
+};
+var median = (...numbers) => {
+  if (!Array.isArray(numbers) || numbers.length === 0) return 0;
+  const validNumbers = numbers.filter(Number.isFinite);
+  if (validNumbers.length === 0) return 0;
+  validNumbers.sort((a, b) => a - b);
+  const mid = Math.floor(validNumbers.length / 2);
+  return validNumbers.length % 2 === 0 ? (validNumbers[mid - 1] + validNumbers[mid]) / 2 : validNumbers[mid];
+};
+function product(...values) {
+  return values.reduce((prod, val) => prod * val, 1);
+}
+export {
+  abs,
+  add,
+  average,
+  ceil,
+  clamp,
+  divide,
+  factorial,
+  floor,
+  gcd,
+  invLerp,
+  lcm,
+  lerp,
+  mapRange,
+  max,
+  median,
+  min,
+  modulo,
+  power,
+  product,
+  round,
+  sign,
+  sqrt,
+  subtract,
+  sum,
+  trunc
+};

package/dist/lib/maths/fn/complex.cjs

@@ -0,0 +1,268 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/maths/fn/complex.ts
+var complex_exports = {};
+__export(complex_exports, {
+  addComplex: () => addComplex,
+  argumentComplex: () => argumentComplex,
+  complexEquals: () => complexEquals,
+  conjugateComplex: () => conjugateComplex,
+  cosComplex: () => cosComplex,
+  createComplex: () => createComplex,
+  divideComplex: () => divideComplex,
+  expComplex: () => expComplex,
+  fromPolarComplex: () => fromPolarComplex,
+  getImag: () => getImag,
+  getReal: () => getReal,
+  isZeroComplex: () => isZeroComplex,
+  lnComplex: () => lnComplex,
+  magnitudeComplex: () => magnitudeComplex,
+  multiplyComplex: () => multiplyComplex,
+  negateComplex: () => negateComplex,
+  powerComplex: () => powerComplex,
+  reciprocalComplex: () => reciprocalComplex,
+  sinComplex: () => sinComplex,
+  sqrtComplex: () => sqrtComplex,
+  subtractComplex: () => subtractComplex,
+  toPolarComplex: () => toPolarComplex
+});
+module.exports = __toCommonJS(complex_exports);
+var EPSILON = 1e-10;
+var TWO_PI = 2 * Math.PI;
+function isApproximatelyZero(value) {
+  return Math.abs(value) < EPSILON;
+}
+function approximatelyEqual(a, b) {
+  return Math.abs(a - b) < EPSILON;
+}
+function normalizeComplex(c) {
+  return {
+    real: isApproximatelyZero(c.real) ? 0 : c.real,
+    imag: isApproximatelyZero(c.imag) ? 0 : c.imag
+  };
+}
+function validateNumber(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${name} must be a finite number, got ${value}`);
+  }
+}
+function validateComplexNumber(c, name = "Complex number") {
+  if (!c || typeof c !== "object") {
+    throw new Error(`${name} must be an object`);
+  }
+  validateNumber(c.real, `${name}.real`);
+  validateNumber(c.imag, `${name}.imag`);
+}
+function createComplex(real, imag = 0) {
+  validateNumber(real, "real");
+  validateNumber(imag, "imag");
+  return normalizeComplex({ real, imag });
+}
+function complexEquals(a, b) {
+  validateComplexNumber(a, "First complex number");
+  validateComplexNumber(b, "Second complex number");
+  return approximatelyEqual(a.real, b.real) && approximatelyEqual(a.imag, b.imag);
+}
+function addComplex(a, b) {
+  validateComplexNumber(a, "First complex number");
+  validateComplexNumber(b, "Second complex number");
+  return normalizeComplex({
+    real: a.real + b.real,
+    imag: a.imag + b.imag
+  });
+}
+function subtractComplex(a, b) {
+  validateComplexNumber(a, "First complex number");
+  validateComplexNumber(b, "Second complex number");
+  return normalizeComplex({
+    real: a.real - b.real,
+    imag: a.imag - b.imag
+  });
+}
+function multiplyComplex(a, b) {
+  validateComplexNumber(a, "First complex number");
+  validateComplexNumber(b, "Second complex number");
+  return normalizeComplex({
+    real: a.real * b.real - a.imag * b.imag,
+    imag: a.real * b.imag + a.imag * b.real
+  });
+}
+function divideComplex(a, b) {
+  validateComplexNumber(a, "Numerator complex number");
+  validateComplexNumber(b, "Denominator complex number");
+  const denominator = b.real * b.real + b.imag * b.imag;
+  if (isApproximatelyZero(denominator)) {
+    throw new Error("Cannot divide by zero or near-zero complex number");
+  }
+  return normalizeComplex({
+    real: (a.real * b.real + a.imag * b.imag) / denominator,
+    imag: (a.imag * b.real - a.real * b.imag) / denominator
+  });
+}
+function magnitudeComplex(c) {
+  validateComplexNumber(c);
+  const magnitude = Math.sqrt(c.real * c.real + c.imag * c.imag);
+  return isApproximatelyZero(magnitude) ? 0 : magnitude;
+}
+function conjugateComplex(c) {
+  validateComplexNumber(c);
+  return normalizeComplex({
+    real: c.real,
+    imag: -c.imag
+  });
+}
+function argumentComplex(c) {
+  validateComplexNumber(c);
+  if (isApproximatelyZero(c.real) && isApproximatelyZero(c.imag)) {
+    return 0;
+  }
+  return Math.atan2(c.imag, c.real);
+}
+function toPolarComplex(c) {
+  validateComplexNumber(c);
+  return {
+    magnitude: magnitudeComplex(c),
+    angle: argumentComplex(c)
+  };
+}
+function fromPolarComplex(magnitude, angle) {
+  validateNumber(magnitude, "magnitude");
+  validateNumber(angle, "angle");
+  if (magnitude < -EPSILON) {
+    throw new Error("Magnitude must be non-negative");
+  }
+  let normalizedAngle = angle % TWO_PI;
+  if (normalizedAngle > Math.PI) normalizedAngle -= TWO_PI;
+  if (normalizedAngle <= -Math.PI) normalizedAngle += TWO_PI;
+  const mag = Math.max(0, magnitude);
+  return normalizeComplex({
+    real: mag * Math.cos(normalizedAngle),
+    imag: mag * Math.sin(normalizedAngle)
+  });
+}
+function sqrtComplex(c) {
+  validateComplexNumber(c);
+  if (isApproximatelyZero(c.real) && isApproximatelyZero(c.imag)) {
+    const zero = createComplex(0, 0);
+    return [zero, zero];
+  }
+  const magnitude = magnitudeComplex(c);
+  const angle = argumentComplex(c);
+  const rootMagnitude = Math.sqrt(magnitude);
+  const rootAngle1 = angle / 2;
+  const rootAngle2 = rootAngle1 + Math.PI;
+  return [
+    fromPolarComplex(rootMagnitude, rootAngle1),
+    fromPolarComplex(rootMagnitude, rootAngle2)
+  ];
+}
+function powerComplex(c, exponent) {
+  validateComplexNumber(c);
+  validateNumber(exponent, "exponent");
+  if (isApproximatelyZero(exponent)) {
+    return createComplex(1, 0);
+  }
+  if (approximatelyEqual(exponent, 1)) {
+    return createComplex(c.real, c.imag);
+  }
+  if (approximatelyEqual(exponent, 2)) {
+    return multiplyComplex(c, c);
+  }
+  if (isApproximatelyZero(c.real) && isApproximatelyZero(c.imag)) {
+    if (exponent > 0) {
+      return createComplex(0, 0);
+    } else if (exponent < 0) {
+      throw new Error("Cannot raise zero to a negative power");
+    }
+  }
+  const polar = toPolarComplex(c);
+  const magnitude = Math.pow(polar.magnitude, exponent);
+  const safeMagnitude = magnitude < -EPSILON ? Math.abs(magnitude) : Math.max(0, magnitude);
+  const angle = polar.angle * exponent;
+  return fromPolarComplex(safeMagnitude, angle);
+}
+function lnComplex(c) {
+  validateComplexNumber(c);
+  const magnitude = magnitudeComplex(c);
+  if (isApproximatelyZero(magnitude)) {
+    throw new Error(
+      "Cannot take logarithm of zero or near-zero complex number"
+    );
+  }
+  const angle = argumentComplex(c);
+  return normalizeComplex({
+    real: Math.log(magnitude),
+    imag: angle
+  });
+}
+function expComplex(c) {
+  validateComplexNumber(c);
+  const expReal = Math.exp(c.real);
+  return normalizeComplex({
+    real: expReal * Math.cos(c.imag),
+    imag: expReal * Math.sin(c.imag)
+  });
+}
+function sinComplex(c) {
+  validateComplexNumber(c);
+  return normalizeComplex({
+    real: Math.sin(c.real) * Math.cosh(c.imag),
+    imag: Math.cos(c.real) * Math.sinh(c.imag)
+  });
+}
+function cosComplex(c) {
+  validateComplexNumber(c);
+  return normalizeComplex({
+    real: Math.cos(c.real) * Math.cosh(c.imag),
+    imag: -Math.sin(c.real) * Math.sinh(c.imag)
+  });
+}
+function isZeroComplex(c) {
+  validateComplexNumber(c);
+  return isApproximatelyZero(c.real) && isApproximatelyZero(c.imag);
+}
+function getReal(c) {
+  validateComplexNumber(c);
+  return c.real;
+}
+function getImag(c) {
+  validateComplexNumber(c);
+  return c.imag;
+}
+function negateComplex(c) {
+  validateComplexNumber(c);
+  return normalizeComplex({
+    real: -c.real,
+    imag: -c.imag
+  });
+}
+function reciprocalComplex(c) {
+  validateComplexNumber(c);
+  const denominator = c.real * c.real + c.imag * c.imag;
+  if (isApproximatelyZero(denominator)) {
+    throw new Error(
+      "Cannot calculate reciprocal of zero or near-zero complex number"
+    );
+  }
+  return normalizeComplex({
+    real: c.real / denominator,
+    imag: -c.imag / denominator
+  });
+}

package/dist/lib/maths/fn/complex.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Complex number operations.
+ * @module ComplexFunctions
+ */
+import type { ComplexNumber } from '../types/advanced.js';
+/**
+ * Creates a complex number with validation and normalization.
+ * @param real - Real part
+ * @param imag - Imaginary part
+ * @returns Validated and normalized complex number
+ */
+export declare function createComplex(real: number, imag?: number): ComplexNumber;
+/**
+ * Checks if two complex numbers are approximately equal.
+ * @param a - First complex number
+ * @param b - Second complex number
+ * @returns True if numbers are approximately equal
+ */
+export declare function complexEquals(a: ComplexNumber, b: ComplexNumber): boolean;
+/**
+ * Adds two complex numbers.
+ * @param a - First complex number
+ * @param b - Second complex number
+ * @returns The sum as a complex number
+ */
+export declare function addComplex(a: ComplexNumber, b: ComplexNumber): ComplexNumber;
+/**
+ * Subtracts two complex numbers.
+ * @param a - First complex number
+ * @param b - Second complex number
+ * @returns The difference as a complex number (a - b)
+ */
+export declare function subtractComplex(a: ComplexNumber, b: ComplexNumber): ComplexNumber;
+/**
+ * Multiplies two complex numbers.
+ * @param a - First complex number
+ * @param b - Second complex number
+ * @returns The product as a complex number
+ */
+export declare function multiplyComplex(a: ComplexNumber, b: ComplexNumber): ComplexNumber;
+/**
+ * Divides two complex numbers.
+ * @param a - Numerator complex number
+ * @param b - Denominator complex number
+ * @returns The quotient as a complex number
+ * @throws {Error} If dividing by zero or near-zero complex number
+ */
+export declare function divideComplex(a: ComplexNumber, b: ComplexNumber): ComplexNumber;
+/**
+ * Calculates the magnitude (absolute value) of a complex number.
+ * @param c - The complex number
+ * @returns The magnitude (non-negative)
+ */
+export declare function magnitudeComplex(c: ComplexNumber): number;
+/**
+ * Calculates the conjugate of a complex number.
+ * @param c - The complex number
+ * @returns The complex conjugate
+ */
+export declare function conjugateComplex(c: ComplexNumber): ComplexNumber;
+/**
+ * Calculates the argument (angle) of a complex number in radians.
+ * @param c - The complex number
+ * @returns The principal argument in radians (-π, π]
+ */
+export declare function argumentComplex(c: ComplexNumber): number;
+/**
+ * Converts a complex number to polar form.
+ * @param c - The complex number
+ * @returns Polar representation {magnitude, angle}
+ */
+export declare function toPolarComplex(c: ComplexNumber): {
+    magnitude: number;
+    angle: number;
+};
+/**
+ * Converts polar form to a complex number.
+ * @param magnitude - The magnitude (must be non-negative)
+ * @param angle - The angle in radians
+ * @returns The complex number
+ * @throws {Error} If magnitude is negative
+ */
+export declare function fromPolarComplex(magnitude: number, angle: number): ComplexNumber;
+/**
+ * Calculates the square root of a complex number.
+ * @param c - The complex number
+ * @returns Array of two complex square roots (principal and secondary)
+ */
+export declare function sqrtComplex(c: ComplexNumber): [ComplexNumber, ComplexNumber];
+/**
+ * Calculates the power of a complex number with a real exponent.
+ * @param c - The complex number
+ * @param exponent - The exponent (real number)
+ * @returns The complex number raised to the power
+ */
+export declare function powerComplex(c: ComplexNumber, exponent: number): ComplexNumber;
+/**
+ * Calculates the natural logarithm of a complex number.
+ * @param c - The complex number
+ * @returns The principal value of natural logarithm as a complex number
+ * @throws {Error} If the complex number is zero or near-zero
+ */
+export declare function lnComplex(c: ComplexNumber): ComplexNumber;
+/**
+ * Calculates the exponential of a complex number.
+ * @param c - The complex number
+ * @returns The exponential as a complex number
+ */
+export declare function expComplex(c: ComplexNumber): ComplexNumber;
+/**
+ * Calculates the sine of a complex number.
+ * @param c - The complex number
+ * @returns The sine as a complex number
+ */
+export declare function sinComplex(c: ComplexNumber): ComplexNumber;
+/**
+ * Calculates the cosine of a complex number.
+ * @param c - The complex number
+ * @returns The cosine as a complex number
+ */
+export declare function cosComplex(c: ComplexNumber): ComplexNumber;
+/**
+ * Checks if a complex number is zero (or effectively zero).
+ * @param c - The complex number to check
+ * @returns True if the complex number is effectively zero
+ */
+export declare function isZeroComplex(c: ComplexNumber): boolean;
+/**
+ * Returns the real part of a complex number.
+ * @param c - The complex number
+ * @returns The real part
+ */
+export declare function getReal(c: ComplexNumber): number;
+/**
+ * Returns the imaginary part of a complex number.
+ * @param c - The complex number
+ * @returns The imaginary part
+ */
+export declare function getImag(c: ComplexNumber): number;
+/**
+ * Negates a complex number.
+ * @param c - The complex number
+ * @returns The negated complex number
+ */
+export declare function negateComplex(c: ComplexNumber): ComplexNumber;
+/**
+ * Calculates the reciprocal of a complex number.
+ * @param c - The complex number
+ * @returns The reciprocal (1/c)
+ * @throws {Error} If the complex number is zero or near-zero
+ */
+export declare function reciprocalComplex(c: ComplexNumber): ComplexNumber;
+//# sourceMappingURL=complex.d.ts.map

package/dist/lib/maths/fn/complex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complex.d.ts","sourceRoot":"","sources":["../../../../src/lib/maths/fn/complex.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAmE1D;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,MAAU,GAAG,aAAa,CAI3E;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,OAAO,CAOzE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa,CAQ5E;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,GACf,aAAa,CAQf;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,GACf,aAAa,CAQf;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,GACf,aAAa,CAcf;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAKzD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAOhE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAQxD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,aAAa,GAAG;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAOA;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,aAAa,CAmBf;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,aAAa,GAAG,CAAC,aAAa,EAAE,aAAa,CAAC,CAmB5E;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,CAAC,EAAE,aAAa,EAChB,QAAQ,EAAE,MAAM,GACf,aAAa,CAoCf;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAgBzD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAS1D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAQ1D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAQ1D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,aAAa,GAAG,OAAO,CAGvD;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAGhD;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAGhD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAM7D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAcjE"}