@fluixi/utils 1.0.0-alpha.100

package/dist/lib/maths/constants.cjs

@@ -0,0 +1,70 @@
+/*! @fluixi/utils v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"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/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  Constants: () => Constants,
+  DEGREES_IN_CIRCLE: () => DEGREES_IN_CIRCLE,
+  DEGREES_PER_RADIAN: () => DEGREES_PER_RADIAN,
+  E: () => E,
+  GRADIANS_IN_CIRCLE: () => GRADIANS_IN_CIRCLE,
+  LN10: () => LN10,
+  LN2: () => LN2,
+  LOG10E: () => LOG10E,
+  LOG2E: () => LOG2E,
+  PHI: () => PHI,
+  PI: () => PI,
+  RADIANS_IN_CIRCLE: () => RADIANS_IN_CIRCLE,
+  RADIANS_PER_DEGREE: () => RADIANS_PER_DEGREE,
+  SQRT1_2: () => SQRT1_2,
+  SQRT2: () => SQRT2
+});
+module.exports = __toCommonJS(constants_exports);
+var PI = 3.141592653589793;
+var E = 2.718281828459045;
+var PHI = 1.618033988749894;
+var SQRT2 = 1.4142135623730951;
+var SQRT1_2 = 0.7071067811865476;
+var LN2 = 0.6931471805599453;
+var LN10 = 2.302585092994046;
+var LOG2E = 1.4426950408889634;
+var LOG10E = 0.4342944819032518;
+var DEGREES_IN_CIRCLE = 360;
+var RADIANS_IN_CIRCLE = 2 * PI;
+var GRADIANS_IN_CIRCLE = 400;
+var DEGREES_PER_RADIAN = 180 / PI;
+var RADIANS_PER_DEGREE = PI / 180;
+var Constants = {
+  PI,
+  E,
+  PHI,
+  SQRT2,
+  SQRT1_2,
+  LN2,
+  LN10,
+  LOG2E,
+  LOG10E,
+  DEGREES_IN_CIRCLE,
+  RADIANS_IN_CIRCLE,
+  GRADIANS_IN_CIRCLE,
+  DEGREES_PER_RADIAN,
+  RADIANS_PER_DEGREE
+};

package/dist/lib/maths/constants.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Mathematical constants with precise typing.
+ * @module MathConstants
+ */
+/**
+ * The ratio of a circle's circumference to its diameter.
+ */
+export declare const PI: 3.141592653589793;
+/**
+ * Euler's number, the base of natural logarithms.
+ */
+export declare const E: 2.718281828459045;
+/**
+ * The golden ratio, approximately 1.61803.
+ */
+export declare const PHI: 1.618033988749894;
+/**
+ * Square root of 2.
+ */
+export declare const SQRT2: 1.4142135623730951;
+/**
+ * Square root of 1/2.
+ */
+export declare const SQRT1_2: 0.7071067811865476;
+/**
+ * Natural logarithm of 2.
+ */
+export declare const LN2: 0.6931471805599453;
+/**
+ * Natural logarithm of 10.
+ */
+export declare const LN10: 2.302585092994046;
+/**
+ * Base-2 logarithm of E.
+ */
+export declare const LOG2E: 1.4426950408889634;
+/**
+ * Base-10 logarithm of E.
+ */
+export declare const LOG10E: 0.4342944819032518;
+/**
+ * Degrees in a circle.
+ */
+export declare const DEGREES_IN_CIRCLE: 360;
+/**
+ * Radians in a circle.
+ */
+export declare const RADIANS_IN_CIRCLE: number;
+/**
+ * Gradians in a circle.
+ */
+export declare const GRADIANS_IN_CIRCLE: 400;
+/**
+ * Degrees per radian.
+ */
+export declare const DEGREES_PER_RADIAN: number;
+/**
+ * Radians per degree.
+ */
+export declare const RADIANS_PER_DEGREE: number;
+/**
+ * Mathematical constants object for grouped access.
+ */
+export declare const Constants: {
+    readonly PI: 3.141592653589793;
+    readonly E: 2.718281828459045;
+    readonly PHI: 1.618033988749894;
+    readonly SQRT2: 1.4142135623730951;
+    readonly SQRT1_2: 0.7071067811865476;
+    readonly LN2: 0.6931471805599453;
+    readonly LN10: 2.302585092994046;
+    readonly LOG2E: 1.4426950408889634;
+    readonly LOG10E: 0.4342944819032518;
+    readonly DEGREES_IN_CIRCLE: 360;
+    readonly RADIANS_IN_CIRCLE: number;
+    readonly GRADIANS_IN_CIRCLE: 400;
+    readonly DEGREES_PER_RADIAN: number;
+    readonly RADIANS_PER_DEGREE: number;
+};
+/**
+ * Type inference for mathematical constants.
+ */
+export type MathConstants = typeof Constants;
+//# sourceMappingURL=constants.d.ts.map

package/dist/lib/maths/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/lib/maths/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,EAAE,EAAG,iBAA0B,CAAC;AAE7C;;GAEG;AACH,eAAO,MAAM,CAAC,EAAG,iBAA0B,CAAC;AAE5C;;GAEG;AACH,eAAO,MAAM,GAAG,EAAG,iBAA0B,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,KAAK,EAAG,kBAA2B,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,OAAO,EAAG,kBAA2B,CAAC;AAEnD;;GAEG;AACH,eAAO,MAAM,GAAG,EAAG,kBAA2B,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,IAAI,EAAG,iBAA0B,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,KAAK,EAAG,kBAA2B,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,MAAM,EAAG,kBAA2B,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAG,GAAY,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAa,MAAM,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAG,GAAY,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAe,MAAM,CAAC;AAErD;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAe,MAAM,CAAC;AAErD;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;CAeZ,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,SAAS,CAAC"}

package/dist/lib/maths/constants.js

@@ -0,0 +1,79 @@
+/**
+ * Mathematical constants with precise typing.
+ * @module MathConstants
+ */
+/**
+ * The ratio of a circle's circumference to its diameter.
+ */
+export const PI = 3.141592653589793;
+/**
+ * Euler's number, the base of natural logarithms.
+ */
+export const E = 2.718281828459045;
+/**
+ * The golden ratio, approximately 1.61803.
+ */
+export const PHI = 1.618033988749894;
+/**
+ * Square root of 2.
+ */
+export const SQRT2 = 1.4142135623730951;
+/**
+ * Square root of 1/2.
+ */
+export const SQRT1_2 = 0.7071067811865476;
+/**
+ * Natural logarithm of 2.
+ */
+export const LN2 = 0.6931471805599453;
+/**
+ * Natural logarithm of 10.
+ */
+export const LN10 = 2.302585092994046;
+/**
+ * Base-2 logarithm of E.
+ */
+export const LOG2E = 1.4426950408889634;
+/**
+ * Base-10 logarithm of E.
+ */
+export const LOG10E = 0.4342944819032518;
+/**
+ * Degrees in a circle.
+ */
+export const DEGREES_IN_CIRCLE = 360;
+/**
+ * Radians in a circle.
+ */
+export const RADIANS_IN_CIRCLE = 2 * PI;
+/**
+ * Gradians in a circle.
+ */
+export const GRADIANS_IN_CIRCLE = 400;
+/**
+ * Degrees per radian.
+ */
+export const DEGREES_PER_RADIAN = 180 / PI;
+/**
+ * Radians per degree.
+ */
+export const RADIANS_PER_DEGREE = PI / 180;
+/**
+ * Mathematical constants object for grouped access.
+ */
+export const Constants = {
+    PI,
+    E,
+    PHI,
+    SQRT2,
+    SQRT1_2,
+    LN2,
+    LN10,
+    LOG2E,
+    LOG10E,
+    DEGREES_IN_CIRCLE,
+    RADIANS_IN_CIRCLE,
+    GRADIANS_IN_CIRCLE,
+    DEGREES_PER_RADIAN,
+    RADIANS_PER_DEGREE,
+};

package/dist/lib/maths/constants.mjs

@@ -0,0 +1,50 @@
+/*! @fluixi/utils v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// src/lib/maths/constants.ts
+var PI = 3.141592653589793;
+var E = 2.718281828459045;
+var PHI = 1.618033988749894;
+var SQRT2 = 1.4142135623730951;
+var SQRT1_2 = 0.7071067811865476;
+var LN2 = 0.6931471805599453;
+var LN10 = 2.302585092994046;
+var LOG2E = 1.4426950408889634;
+var LOG10E = 0.4342944819032518;
+var DEGREES_IN_CIRCLE = 360;
+var RADIANS_IN_CIRCLE = 2 * PI;
+var GRADIANS_IN_CIRCLE = 400;
+var DEGREES_PER_RADIAN = 180 / PI;
+var RADIANS_PER_DEGREE = PI / 180;
+var Constants = {
+  PI,
+  E,
+  PHI,
+  SQRT2,
+  SQRT1_2,
+  LN2,
+  LN10,
+  LOG2E,
+  LOG10E,
+  DEGREES_IN_CIRCLE,
+  RADIANS_IN_CIRCLE,
+  GRADIANS_IN_CIRCLE,
+  DEGREES_PER_RADIAN,
+  RADIANS_PER_DEGREE
+};
+export {
+  Constants,
+  DEGREES_IN_CIRCLE,
+  DEGREES_PER_RADIAN,
+  E,
+  GRADIANS_IN_CIRCLE,
+  LN10,
+  LN2,
+  LOG10E,
+  LOG2E,
+  PHI,
+  PI,
+  RADIANS_IN_CIRCLE,
+  RADIANS_PER_DEGREE,
+  SQRT1_2,
+  SQRT2
+};

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

@@ -0,0 +1,231 @@
+"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/advanced.ts
+var advanced_exports = {};
+__export(advanced_exports, {
+  addFractions: () => addFractions,
+  cbrt: () => cbrt,
+  evaluatePolynomial: () => evaluatePolynomial,
+  exp: () => exp,
+  ln: () => ln,
+  log: () => log,
+  log10: () => log10,
+  log2: () => log2,
+  multiplyFractions: () => multiplyFractions,
+  normalize: () => normalize,
+  nthRoot: () => nthRoot,
+  percentage: () => percentage,
+  range: () => range,
+  simplifyFraction: () => simplifyFraction,
+  solveQuadratic: () => solveQuadratic,
+  toBase: () => toBase,
+  toOrdinal: () => toOrdinal,
+  truncateDecimals: () => truncateDecimals,
+  wrap: () => wrap
+});
+module.exports = __toCommonJS(advanced_exports);
+
+// src/lib/maths/fn/basic.ts
+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;
+};
+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;
+}
+
+// src/lib/maths/fn/advanced.ts
+function ln(value) {
+  if (value <= 0) {
+    throw new Error("Natural logarithm is only defined for positive numbers");
+  }
+  return Math.log(value);
+}
+function log10(value) {
+  if (value <= 0) {
+    throw new Error("Logarithm is only defined for positive numbers");
+  }
+  return Math.log10(value);
+}
+function log2(value) {
+  if (value <= 0) {
+    throw new Error("Logarithm is only defined for positive numbers");
+  }
+  return Math.log2(value);
+}
+function log(value, base) {
+  if (value <= 0 || base <= 0) {
+    throw new Error("Logarithm is only defined for positive numbers and bases");
+  }
+  return Math.log(value) / Math.log(base);
+}
+function exp(x) {
+  return Math.exp(x);
+}
+function cbrt(value) {
+  return Math.cbrt(value);
+}
+function nthRoot(value, n) {
+  if (n === 0) {
+    throw new Error("Cannot calculate 0th root");
+  }
+  if (value < 0 && n % 2 === 0) {
+    throw new Error("Cannot calculate even root of negative number");
+  }
+  const exponent = 1 / n;
+  return Math.sign(value) * Math.pow(Math.abs(value), exponent);
+}
+function solveQuadratic(a, b, c) {
+  if (a === 0) {
+    if (b === 0) return [];
+    return [-c / b];
+  }
+  const discriminant = b * b - 4 * a * c;
+  if (discriminant < 0) {
+    return [];
+  } else if (discriminant === 0) {
+    return [-b / (2 * a)];
+  } else {
+    const sqrtDiscriminant = Math.sqrt(discriminant);
+    return [
+      (-b - sqrtDiscriminant) / (2 * a),
+      (-b + sqrtDiscriminant) / (2 * a)
+    ];
+  }
+}
+function evaluatePolynomial(coefficients, x) {
+  let result = 0;
+  for (let i = 0; i < coefficients.length; i++) {
+    result = result * x + coefficients[i];
+  }
+  return result;
+}
+function simplifyFraction(fraction) {
+  const divisor = gcd(fraction.numerator, fraction.denominator);
+  return {
+    numerator: fraction.numerator / divisor,
+    denominator: fraction.denominator / divisor
+  };
+}
+function addFractions(a, b) {
+  const numerator = a.numerator * b.denominator + b.numerator * a.denominator;
+  const denominator = a.denominator * b.denominator;
+  return simplifyFraction({ numerator, denominator });
+}
+function multiplyFractions(a, b) {
+  const numerator = a.numerator * b.numerator;
+  const denominator = a.denominator * b.denominator;
+  return simplifyFraction({ numerator, denominator });
+}
+var percentage = (value, total, precision = 2) => {
+  if (total === 0) return 0;
+  const percent = value / total * 100;
+  return round(percent, precision);
+};
+var toBase = (number, base, minLength = 1) => {
+  if (base < 2 || base > 36) {
+    throw new Error("Base must be between 2 and 36");
+  }
+  const result = number.toString(base);
+  return result.padStart(minLength, "0");
+};
+var toOrdinal = (n) => {
+  const suffix = ["th", "st", "nd", "rd"];
+  const v = n % 100;
+  return n + (suffix[(v - 20) % 10] || suffix[v] || suffix[0]);
+};
+var range = (start, end, step = 1) => {
+  const result = [];
+  if (step === 0) return result;
+  if (step > 0) {
+    for (let i = start; i < end; i += step) {
+      result.push(i);
+    }
+  } else {
+    for (let i = start; i > end; i += step) {
+      result.push(i);
+    }
+  }
+  return result;
+};
+var truncateDecimals = (value, decimalPlaces) => {
+  if (!Number.isFinite(value)) return value;
+  const factor = 10 ** decimalPlaces;
+  return Math.trunc(value * factor) / factor;
+};
+var normalize = (value, min, max) => {
+  if (min === max) return 0;
+  return (value - min) / (max - min);
+};
+var wrap = (value, min, max) => {
+  const range2 = max - min;
+  return ((value - min) % range2 + range2) % range2 + min;
+};

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

@@ -0,0 +1,149 @@
+/**
+ * Advanced mathematical operations.
+ * @module AdvancedMathFunctions
+ */
+import type { Fraction } from '../types/advanced.js';
+/**
+ * Calculates the natural logarithm of a number.
+ * @param value - The number
+ * @returns The natural logarithm
+ * @throws {Error} If value is not positive
+ */
+export declare function ln(value: number): number;
+/**
+ * Calculates the base-10 logarithm of a number.
+ * @param value - The number
+ * @returns The base-10 logarithm
+ * @throws {Error} If value is not positive
+ */
+export declare function log10(value: number): number;
+/**
+ * Calculates the base-2 logarithm of a number.
+ * @param value - The number
+ * @returns The base-2 logarithm
+ * @throws {Error} If value is not positive
+ */
+export declare function log2(value: number): number;
+/**
+ * Calculates the logarithm of a number with a custom base.
+ * @param value - The number
+ * @param base - The logarithm base
+ * @returns The logarithm with specified base
+ * @throws {Error} If value or base is not positive
+ */
+export declare function log(value: number, base: number): number;
+/**
+ * Calculates the exponential function e^x.
+ * @param x - The exponent
+ * @returns e raised to the power x
+ */
+export declare function exp(x: number): number;
+/**
+ * Calculates the cube root of a number.
+ * @param value - The number
+ * @returns The cube root
+ */
+export declare function cbrt(value: number): number;
+/**
+ * Calculates the nth root of a number.
+ * @param value - The number
+ * @param n - The root degree
+ * @returns The nth root
+ * @throws {Error} If n is 0 or value is negative for even n
+ */
+export declare function nthRoot(value: number, n: number): number;
+/**
+ * Solves a quadratic equation ax^2 + bx + c = 0.
+ * @param a - Coefficient of x^2
+ * @param b - Coefficient of x
+ * @param c - Constant term
+ * @returns Array of real roots (0, 1, or 2 roots)
+ */
+export declare function solveQuadratic(a: number, b: number, c: number): number[];
+/**
+ * Evaluates a polynomial at a given x value.
+ * @param coefficients - Polynomial coefficients from highest to lowest degree
+ * @param x - The value to evaluate at
+ * @returns The polynomial value at x
+ */
+export declare function evaluatePolynomial(coefficients: number[], x: number): number;
+/**
+ * Simplifies a fraction to its lowest terms.
+ * @param fraction - The fraction to simplify
+ * @returns The simplified fraction
+ */
+export declare function simplifyFraction(fraction: Fraction): Fraction;
+/**
+ * Adds two fractions.
+ * @param a - First fraction
+ * @param b - Second fraction
+ * @returns The sum as a simplified fraction
+ */
+export declare function addFractions(a: Fraction, b: Fraction): Fraction;
+/**
+ * Multiplies two fractions.
+ * @param a - First fraction
+ * @param b - Second fraction
+ * @returns The product as a simplified fraction
+ */
+export declare function multiplyFractions(a: Fraction, b: Fraction): Fraction;
+/**
+ * Calculates the percentage of a number.
+ * @param value - The number
+ * @param percentage - The percentage (e.g., 25 for 25%)
+ * @param precision - The number of decimal places
+ * @returns The percentage of the number
+ */
+export declare const percentage: (value: number, total: number, precision?: number) => number;
+/**
+ * Converts a number to a specified base (2-36)
+ *
+ * @param number - The number
+ */
+export declare const toBase: (number: number, base: number, minLength?: number) => string;
+/**
+ * Converts a number to ordinal string (1st, 2nd, 3rd, etc.)
+ *
+ * @param n - The number
+ */
+export declare const toOrdinal: (n: number) => string;
+/**
+ * Generates a sequence of numbers
+ *
+ * @param start - The starting number
+ * @param end - The ending number
+ * @param step - The step size
+ *
+ * @returns An array of numbers
+ */
+export declare const range: (start: number, end: number, step?: number) => number[];
+/**
+ * Limits the number of decimal places without rounding
+ *
+ * @param value - The number
+ * @param decimalPlaces - The number of decimal places
+ *
+ * @returns The truncated number
+ */
+export declare const truncateDecimals: (value: number, decimalPlaces: number) => number;
+/**
+ * Normalizes a value to a 0-1 range based on min/max
+ *
+ * @param value - The number
+ * @param min - The minimum value
+ * @param max - The maximum value
+ *
+ * @returns The normalized value
+ */
+export declare const normalize: (value: number, min: number, max: number) => number;
+/**
+ * Wraps a value within a range (like modulo for floats)
+ *
+ * @param value - The number
+ * @param min - The minimum value
+ * @param max - The maximum value
+ *
+ * @returns The wrapped value
+ */
+export declare const wrap: (value: number, min: number, max: number) => number;
+//# sourceMappingURL=advanced.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"advanced.d.ts","sourceRoot":"","sources":["../../../../src/lib/maths/fn/advanced.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGrD;;;;;GAKG;AACH,wBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKxC;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAK3C;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAK1C;AAED;;;;;;GAMG;AACH,wBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAKvD;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAErC;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE1C;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAWxD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAoBxE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAM5E;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAM7D;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAI/D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAIpE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GACrB,OAAO,MAAM,EACb,OAAO,MAAM,EACb,YAAW,MAAU,KACpB,MAIF,CAAC;AAGF;;;;GAIG;AACH,eAAO,MAAM,MAAM,GACjB,QAAQ,MAAM,EACd,MAAM,MAAM,EACZ,YAAW,MAAU,KACpB,MAOF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,SAAS,GAAI,GAAG,MAAM,KAAG,MAIrC,CAAC;AAGF;;;;;;;;GAQG;AACH,eAAO,MAAM,KAAK,GAChB,OAAO,MAAM,EACb,KAAK,MAAM,EACX,OAAM,MAAU,KACf,MAAM,EAgBR,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAC3B,OAAO,MAAM,EACb,eAAe,MAAM,KACpB,MAKF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,GACpB,OAAO,MAAM,EACb,KAAK,MAAM,EACX,KAAK,MAAM,KACV,MAGF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,GAAI,OAAO,MAAM,EAAE,KAAK,MAAM,EAAE,KAAK,MAAM,KAAG,MAG9D,CAAC"}