@fluixi/utils 1.0.0-alpha.100

package/dist/lib/maths/formatter.cjs

@@ -0,0 +1,61 @@
+"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/formatter.ts
+var formatter_exports = {};
+__export(formatter_exports, {
+  formatBytes: () => formatBytes,
+  formatCurrency: () => formatCurrency,
+  formatNumber: () => formatNumber,
+  formatPercent: () => formatPercent
+});
+module.exports = __toCommonJS(formatter_exports);
+var formatNumber = (value, options = {}) => {
+  const {
+    locale = "en-US",
+    minimumFractionDigits = 0,
+    maximumFractionDigits = 20
+  } = options;
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits,
+    maximumFractionDigits
+  }).format(value);
+};
+var formatCurrency = (value, currency = "USD", locale = "en-US") => {
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency
+  }).format(value);
+};
+var formatBytes = (bytes, decimals = 2) => {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+};
+var formatPercent = (value, decimals = 2, locale = "en-US") => {
+  const percent = value * 100;
+  return new Intl.NumberFormat(locale, {
+    style: "percent",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: Math.max(0, decimals)
+  }).format(percent / 100);
+};

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

@@ -0,0 +1,35 @@
+/**
+ * Formats a number with thousand separators and decimal places
+ * @param value - Number to format
+ * @param options - Options object with locale, minimumFractionDigits, and maximumFractionDigits
+ * Optimized: Uses Intl.NumberFormat for locale-aware formatting
+ */
+export declare const formatNumber: (value: number, options?: {
+    locale?: Intl.LocalesArgument;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+}) => string;
+/**
+ * Formats a number as currency
+ * @param value - Number to format
+ * @param currency - Currency code (default: 'USD')
+ * @param locale - Locale string (default: 'en-US')
+ * Optimized: Uses Intl.NumberFormat
+ */
+export declare const formatCurrency: (value: number, currency?: string, locale?: string) => string;
+/**
+ * Formats bytes to human-readable string (KB, MB, GB, etc.)
+ * @param bytes - Number of bytes to format
+ * @param decimals - Number of decimal places to include (default: 2)
+ * Optimized: Logarithmic calculation for units
+ */
+export declare const formatBytes: (bytes: number, decimals?: number) => string;
+/**
+ * Formats a number as a percentage
+ * @param value - Number to format
+ * @param decimals - Number of decimal places to include (default: 2)
+ * @param locale - Locale string (default: 'en-US')
+ * Optimized: Single multiplication and formatting
+ */
+export declare const formatPercent: (value: number, decimals?: number, locale?: string) => string;
+//# sourceMappingURL=formatter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../../src/lib/maths/formatter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GACvB,OAAO,MAAM,EACb,UAAS;IACP,MAAM,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC;IAC9B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAC3B,KACL,MAWF,CAAC;AAGF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GACzB,OAAO,MAAM,EACb,WAAU,MAAc,EACxB,SAAQ,MAAgB,KACvB,MAKF,CAAC;AAGF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,MAAM,EACb,WAAU,MAAU,KACnB,MASF,CAAC;AAGF;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,MAAM,EACb,WAAU,MAAU,EACpB,SAAQ,MAAgB,KACvB,MAOF,CAAC"}

package/dist/lib/maths/formatter.js

@@ -0,0 +1,56 @@
+/**
+ * Formats a number with thousand separators and decimal places
+ * @param value - Number to format
+ * @param options - Options object with locale, minimumFractionDigits, and maximumFractionDigits
+ * Optimized: Uses Intl.NumberFormat for locale-aware formatting
+ */
+export const formatNumber = (value, options = {}) => {
+    const { locale = 'en-US', minimumFractionDigits = 0, maximumFractionDigits = 20 } = options;
+    return new Intl.NumberFormat(locale, {
+        minimumFractionDigits,
+        maximumFractionDigits
+    }).format(value);
+};
+/**
+ * Formats a number as currency
+ * @param value - Number to format
+ * @param currency - Currency code (default: 'USD')
+ * @param locale - Locale string (default: 'en-US')
+ * Optimized: Uses Intl.NumberFormat
+ */
+export const formatCurrency = (value, currency = 'USD', locale = 'en-US') => {
+    return new Intl.NumberFormat(locale, {
+        style: 'currency',
+        currency
+    }).format(value);
+};
+/**
+ * Formats bytes to human-readable string (KB, MB, GB, etc.)
+ * @param bytes - Number of bytes to format
+ * @param decimals - Number of decimal places to include (default: 2)
+ * Optimized: Logarithmic calculation for units
+ */
+export const formatBytes = (bytes, decimals = 2) => {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+};
+/**
+ * Formats a number as a percentage
+ * @param value - Number to format
+ * @param decimals - Number of decimal places to include (default: 2)
+ * @param locale - Locale string (default: 'en-US')
+ * Optimized: Single multiplication and formatting
+ */
+export const formatPercent = (value, decimals = 2, locale = 'en-US') => {
+    const percent = value * 100;
+    return new Intl.NumberFormat(locale, {
+        style: 'percent',
+        minimumFractionDigits: 0,
+        maximumFractionDigits: Math.max(0, decimals),
+    }).format(percent / 100);
+};

package/dist/lib/maths/formatter.mjs

@@ -0,0 +1,40 @@
+// src/lib/maths/formatter.ts
+var formatNumber = (value, options = {}) => {
+  const {
+    locale = "en-US",
+    minimumFractionDigits = 0,
+    maximumFractionDigits = 20
+  } = options;
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits,
+    maximumFractionDigits
+  }).format(value);
+};
+var formatCurrency = (value, currency = "USD", locale = "en-US") => {
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency
+  }).format(value);
+};
+var formatBytes = (bytes, decimals = 2) => {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+};
+var formatPercent = (value, decimals = 2, locale = "en-US") => {
+  const percent = value * 100;
+  return new Intl.NumberFormat(locale, {
+    style: "percent",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: Math.max(0, decimals)
+  }).format(percent / 100);
+};
+export {
+  formatBytes,
+  formatCurrency,
+  formatNumber,
+  formatPercent
+};

package/dist/lib/maths/guards.cjs

@@ -0,0 +1,164 @@
+/*! @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/guards.ts
+var guards_exports = {};
+__export(guards_exports, {
+  approxEqual: () => approxEqual,
+  isComplexNumber: () => isComplexNumber,
+  isEven: () => isEven,
+  isFiniteNumber: () => isFiniteNumber,
+  isFloat: () => isFloat,
+  isFraction: () => isFraction,
+  isInRange: () => isInRange,
+  isInt: () => isInt,
+  isInteger: () => isInteger,
+  isMatrix: () => isMatrix,
+  isNegative: () => isNegative,
+  isNonNegative: () => isNonNegative,
+  isNonPositive: () => isNonPositive,
+  isNumber: () => isNumber,
+  isNumeric: () => isNumeric,
+  isNumericString: () => isNumericString,
+  isOdd: () => isOdd,
+  isPositive: () => isPositive,
+  isPowerOfTwo: () => isPowerOfTwo,
+  isPrime: () => isPrime,
+  isSafeInteger: () => isSafeInteger,
+  isVector2D: () => isVector2D,
+  isVector3D: () => isVector3D,
+  isZero: () => isZero
+});
+module.exports = __toCommonJS(guards_exports);
+var isNumericString = (value) => {
+  const trimmed = value.trim();
+  if (trimmed === "") return false;
+  if (!/^[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$/.test(trimmed)) return false;
+  const num = Number(trimmed);
+  return Number.isFinite(num);
+};
+var isNumeric = (value) => {
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value === "string") return isNumericString(value);
+  return false;
+};
+var isInt = (value) => {
+  if (typeof value === "number") {
+    return Number.isInteger(value);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return false;
+    if (!/^[-+]?\d+$/.test(trimmed)) return false;
+    const num2 = Number(trimmed);
+    return Number.isInteger(num2) && Number.isFinite(num2);
+  }
+  if (typeof value === "boolean" || value == null) {
+    return false;
+  }
+  if (Array.isArray(value)) return false;
+  const num = Number(value);
+  return !Number.isNaN(num) && Number.isInteger(num) && Number.isFinite(num);
+};
+var isNumber = (value) => {
+  return typeof value === "number" && Number.isFinite(value);
+};
+var isSafeInteger = (value) => {
+  return typeof value === "number" && Number.isSafeInteger(value);
+};
+var isFloat = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return false;
+  return !Number.isInteger(value);
+};
+function isInteger(value) {
+  return Number.isInteger(value);
+}
+function isFiniteNumber(value) {
+  return Number.isFinite(value);
+}
+function isVector2D(value) {
+  return typeof value === "object" && value !== null && "x" in value && "y" in value && typeof value.x === "number" && typeof value.y === "number";
+}
+function isVector3D(value) {
+  return typeof value === "object" && value !== null && "x" in value && "y" in value && "z" in value && typeof value.x === "number" && typeof value.y === "number" && typeof value.z === "number";
+}
+function isComplexNumber(value) {
+  return typeof value === "object" && value !== null && "real" in value && "imag" in value && typeof value.real === "number" && typeof value.imag === "number";
+}
+function isFraction(value) {
+  return typeof value === "object" && value !== null && "numerator" in value && "denominator" in value && typeof value.numerator === "number" && typeof value.denominator === "number" && value.denominator !== 0;
+}
+function isMatrix(value) {
+  return typeof value === "object" && value !== null && "rows" in value && "columns" in value && "data" in value && typeof value.rows === "number" && typeof value.columns === "number" && Array.isArray(value.data) && value.data.every((row) => Array.isArray(row));
+}
+var isPositive = (value) => {
+  return Number.isFinite(value) && value > 0;
+};
+var isNegative = (value) => {
+  return Number.isFinite(value) && value < 0;
+};
+function isNonNegative(value) {
+  return Number.isFinite(value) && value >= 0;
+}
+function isNonPositive(value) {
+  return Number.isFinite(value) && value <= 0;
+}
+var isZero = (value, epsilon = 1e-10) => {
+  return Number.isFinite(value) && Math.abs(value) < epsilon;
+};
+function isInRange(value, min, max, inclusive = true) {
+  return inclusive ? value >= min && value <= max : value > min && value < max;
+}
+function isEven(value) {
+  return (value & 1) === 0;
+}
+function isOdd(value) {
+  return (value & 1) === 1;
+}
+var isPrime = (n) => {
+  if (!Number.isInteger(n)) {
+    return false;
+  }
+  if (n <= 1) return false;
+  if (n <= 3) return true;
+  if (n % 2 === 0 || n % 3 === 0) return false;
+  for (let i = 5; i * i <= n; i += 6) {
+    if (n % i === 0 || n % (i + 2) === 0) return false;
+  }
+  return true;
+};
+var approxEqual = (a, b, epsilon = Math.E) => {
+  if (a === b) return true;
+  if (!Number.isFinite(a) || !Number.isFinite(b)) {
+    return a === b;
+  }
+  const absA = Math.abs(a);
+  const absB = Math.abs(b);
+  const diff = Math.abs(a - b);
+  if (a === 0 || b === 0 || diff < epsilon) {
+    return diff < epsilon;
+  }
+  if (diff > epsilon) return false;
+  const relativeError = diff / Math.min(absA + absB, Number.MAX_SAFE_INTEGER);
+  return relativeError < epsilon;
+};
+var isPowerOfTwo = (n) => {
+  return n > 0 && (n & n - 1) === 0;
+};

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

@@ -0,0 +1,166 @@
+/**
+ * Type guard functions for mathematical types.
+ * @module TypeGuards
+ */
+import type { Integer, Vector2D, Vector3D, ComplexNumber, Fraction } from './types/index.js';
+/**
+ * Checks if a string is a valid numeric string.
+ * @param value - The string to check
+ * @returns True if the string is a valid numeric string
+ */
+export declare const isNumericString: (value: string) => boolean;
+/**
+ * Type guard to check if a value is numeric.
+ * @param value - The value to check
+ * @returns True if the value is numeric
+ */
+export declare const isNumeric: (value: unknown) => value is number | string;
+/**
+ * Checks if a value is an integer with high performance
+ * @param value - The value to check
+ * @returns True if the value is a valid integer
+ * @example
+* isInt(42) // true
+* isInt("42") // true
+* isInt("42.5") // false
+* isInt(null) // false
+*/
+export declare const isInt: (value: unknown) => value is number;
+/**
+ * Checks if a value is a finite number (not NaN, Infinity, or string)
+ * @param value - The value to check
+ * @returns True if the value is a finite number
+ * @example
+* isNumber(42) // true
+* isNumber(NaN) // false
+* isNumber(Infinity) // false
+* isNumber("42") // false
+*/
+export declare const isNumber: (value: unknown) => value is number;
+/**
+ * Checks if a value is a safe integer within Number.MAX_SAFE_INTEGER range
+ * @param value - The value to check
+ * @returns True if value is a safe integer
+ * @example
+* isSafeInteger(42) // true
+* isSafeInteger(9007199254740992) // false (beyond safe range)
+*/
+export declare const isSafeInteger: (value: unknown) => boolean;
+/**
+ * Checks if a value is a float (not an integer)
+ * @param value - The value to check
+ * @returns True if the value is a float
+*/
+export declare const isFloat: (value: unknown) => boolean;
+/**
+ * Type guard to check if a number is an integer.
+ * @param value - The number to check
+ * @returns True if the number is an integer
+ */
+export declare function isInteger(value: unknown): value is Integer;
+/**
+ * Type guard to check if a number is a finite number.
+ * @param value - The number to check
+ * @returns True if the number is finite
+ */
+export declare function isFiniteNumber(value: number): boolean;
+/**
+ * Type guard to check if a value is a valid Vector2D.
+ * @param value - The value to check
+ * @returns True if the value is a valid Vector2D
+ */
+export declare function isVector2D(value: unknown): value is Vector2D;
+/**
+ * Type guard to check if a value is a valid Vector3D.
+ * @param value - The value to check
+ * @returns True if the value is a valid Vector3D
+ */
+export declare function isVector3D(value: unknown): value is Vector3D;
+/**
+ * Type guard to check if a value is a valid ComplexNumber.
+ * @param value - The value to check
+ * @returns True if the value is a valid ComplexNumber
+ */
+export declare function isComplexNumber(value: unknown): value is ComplexNumber;
+/**
+ * Type guard to check if a value is a valid Fraction.
+ * @param value - The value to check
+ * @returns True if the value is a valid Fraction
+ */
+export declare function isFraction(value: unknown): value is Fraction;
+/**
+ * Type guard to check if a value is a valid Matrix.
+ * @param value - The value to check
+ * @returns True if the value is a valid Matrix
+ */
+export declare function isMatrix(value: unknown): value is import('./types/index.js').Matrix<any, any>;
+/**
+ * Type guard to check if a number is positive (> 0).
+ * @param value - The number to check
+ * @returns True if the number is positive
+ */
+export declare const isPositive: (value: number) => boolean;
+/**
+ * Type guard to check if a number is negative (< 0).
+ * @param value - The number to check
+ * @returns True if the number is negative
+ */
+export declare const isNegative: (value: number) => boolean;
+/**
+ * Type guard to check if a number is non-negative (>= 0).
+ * @param value - The number to check
+ * @returns True if the number is non-negative
+ */
+export declare function isNonNegative(value: number): boolean;
+/**
+ * Type guard to check if a number is non-positive (<= 0).
+ * @param value - The number to check
+ * @returns True if the number is non-positive
+ */
+export declare function isNonPositive(value: number): boolean;
+/**
+ * Checks if a number is zero (or very close to zero)
+ */
+export declare const isZero: (value: number, epsilon?: number) => boolean;
+/**
+ * Type guard to check if a number is within a range (inclusive).
+ * @param value - The number to check
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @param inclusive - Whether the range is inclusive
+ * @returns True if the number is within the range
+ */
+export declare function isInRange(value: number, min: number, max: number, inclusive?: boolean): boolean;
+/**
+ * Type guard to check if a number is even.
+ * @param value - The number to check
+ * @returns True if the number is even
+ */
+export declare function isEven(value: number): boolean;
+/**
+ * Type guard to check if a number is odd.
+ * @param value - The number to check
+ * @returns True if the number is odd
+ */
+export declare function isOdd(value: number): boolean;
+/**
+ * Checks if a number is prime.
+ * @param n - The number to check
+ * @returns True if the number is prime, false otherwise
+ */
+export declare const isPrime: (n: number) => boolean;
+/**
+ * Checks if two numbers are approximately equal.
+ * @param a - First number
+ * @param b - Second number
+ * @param epsilon - The maximum allowed difference between the numbers
+ * @returns True if the numbers are approximately equal, false otherwise
+*/
+export declare const approxEqual: (a: number, b: number, epsilon?: number) => boolean;
+/**
+ * Checks if a number is a power of two
+ * @param n - The number to check
+ * Optimized: Bitwise trick
+ */
+export declare const isPowerOfTwo: (n: number) => boolean;
+//# sourceMappingURL=guards.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../../src/lib/maths/guards.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE7F;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,KAAG,OAS/C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,GAAG,MAI5D,CAAC;AAEF;;;;;;;;;EASE;AACF,eAAO,MAAM,KAAK,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MA4B/C,CAAC;AAIF;;;;;;;;;EASE;AACF,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAElD,CAAC;AAGF;;;;;;;EAOE;AACF,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,OAE9C,CAAC;AAGF;;;;EAIE;AACF,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,KAAG,OAGxC,CAAC;AACF;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAS5D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAW5D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAStE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAU5D;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,kBAAkB,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAY7F;AAED;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,KAAG,OAE1C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,KAAG,OAE1C,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;GAEG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,MAAM,EAAE,UAAS,MAAc,KAAG,OAE/D,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,GAAE,OAAc,GAAG,OAAO,CAErG;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAG7C;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAG5C;AAED;;;;GAIG;AACH,eAAO,MAAM,OAAO,GAAI,GAAG,MAAM,KAAG,OAenC,CAAC;AAEF;;;;;;EAME;AACF,eAAO,MAAM,WAAW,GACtB,GAAG,MAAM,EACT,GAAG,MAAM,EACT,UAAS,MAAe,KACvB,OAqBF,CAAC;AAGF;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,GAAG,MAAM,KAAG,OAExC,CAAC"}