@danielsimonjr/mathts-core 0.14.1 → 0.15.0

package/dist/arithmetic/scalar.d.ts

@@ -0,0 +1,56 @@
+import { BigNumber } from '../types/bignumber.js';
+import { Complex } from '../types/complex.js';
+import { Fraction } from '../types/fraction.js';
+/** Any scalar core can do arithmetic on. */
+export type NumericScalar = number | bigint | Complex | Fraction | BigNumber;
+/** Add two scalar values, `x + y`. */
+export declare function addScalar(x: NumericScalar, y: NumericScalar): NumericScalar;
+/** Subtract two scalar values, `x − y` (order preserved through promotion). */
+export declare function subtractScalar(x: NumericScalar, y: NumericScalar): NumericScalar;
+/** Multiply two scalar values, `x · y`. */
+export declare function multiplyScalar(x: NumericScalar, y: NumericScalar): NumericScalar;
+/** Divide two scalar values, `x ÷ y` (order preserved through promotion). */
+export declare function divideScalar(x: NumericScalar, y: NumericScalar): NumericScalar;
+/**
+ * Raise `base` to the power `exp`, treating `exp` as a real exponent.
+ *
+ * The exact `.pow()` of an exact type (Fraction/BigNumber) only supports INTEGER
+ * exponents. A non-integer exponent of an exact base is generally irrational, so
+ * it cannot stay exact — those cases fall back to double-precision `Math.pow`,
+ * returning a plain `number`. (Without this guard, `BigNumber.pow(0.5)` silently
+ * returned 1 and `Fraction.pow(0.5)` threw `BigInt(0.5)`.)
+ */
+export declare function pow(base: NumericScalar, exp: NumericScalar): NumericScalar;
+/** Absolute value. `abs(Complex)` returns the magnitude (a real number). */
+export declare function abs(x: NumericScalar): NumericScalar;
+/** Round toward zero (truncate). Complex components are truncated independently. */
+export declare function fix(x: NumericScalar): NumericScalar;
+/**
+ * Round to the nearest integer, half toward +∞ — matching `Math.round` and
+ * `Fraction.round`. `BigNumber.round` defaults to half-away-from-zero, so it is
+ * given `'halfCeil'` explicitly; otherwise negative half-integers would round
+ * type-dependently (`round(-2.5)` = −2 for number/Fraction but −3 for BigNumber).
+ * Complex components are rounded independently.
+ */
+export declare function round(x: NumericScalar): NumericScalar;
+/**
+ * Equality. Floating-point operands compare with the configured tolerance
+ * (`relTol`/`absTol`); exact types (Fraction, BigNumber) compare exactly —
+ * tolerance is meaningless for an exact rational/decimal.
+ */
+export declare function equal(x: NumericScalar, y: NumericScalar, relTol?: number, absTol?: number): boolean;
+/**
+ * True for values math treats as real-numeric: `number`, `bigint`, `boolean`,
+ * `Fraction`, `BigNumber`. Mirrors mathjs semantics — `boolean` counts (it
+ * coerces to 0/1), while `Complex` is intentionally NOT numeric (callers test it
+ * separately), so `isNumeric(complex)` is `false`. The relocated Unit uses this as
+ * its value-type gate (`isNumeric(value) || isComplex(value)`), and mathjs accepts
+ * `new Unit(true)` — so booleans must pass.
+ */
+export declare function isNumeric(x: unknown): boolean;
+/**
+ * Convert any scalar to a plain JS `number`. A non-real `Complex` (nonzero
+ * imaginary part) has no real-number value and throws.
+ */
+export declare function number(x: NumericScalar): number;
+//# sourceMappingURL=scalar.d.ts.map

package/dist/arithmetic/scalar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalar.d.ts","sourceRoot":"","sources":["../../src/arithmetic/scalar.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,4CAA4C;AAC5C,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;AA0B7E,sCAAsC;AACtC,wBAAgB,SAAS,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa,CAO3E;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa,CAQhF;AAED,2CAA2C;AAC3C,wBAAgB,cAAc,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa,CAQhF;AAED,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,aAAa,CAQ9E;AAED;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAAC,IAAI,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,GAAG,aAAa,CAS1E;AAID,4EAA4E;AAC5E,wBAAgB,GAAG,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAInD;AAED,oFAAoF;AACpF,wBAAgB,GAAG,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAKnD;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,aAAa,GAAG,aAAa,CAMrD;AAID;;;;GAIG;AACH,wBAAgB,KAAK,CACnB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,MAAM,GAAE,MAA8B,EACtC,MAAM,GAAE,MAA8B,GACrC,OAAO,CAQT;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAQ7C;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,CAS/C"}

package/dist/array.d.ts

@@ -0,0 +1,253 @@
+import { Index, Matrix } from './is.js';
+export type NestedArray<T> = T | NestedArray<T>[];
+export interface IdentifiedValue<T> {
+    value: T;
+    identifier: number;
+}
+/**
+ * Calculate the size of a multi dimensional array.
+ * This function checks the size of the first entry, it does not validate
+ * whether all dimensions match. (use function `validate` for that)
+ * @param {Array} x
+ * @return {number[]} size
+ */
+export declare function arraySize<T>(x: NestedArray<T>): number[];
+/**
+ * Validate whether each element in a multi dimensional array has
+ * a size corresponding to the provided size array.
+ * @param {Array} array    Array to be validated
+ * @param {number[]} size  Array with the size of each dimension
+ * @throws DimensionError
+ */
+export declare function validate<T>(array: NestedArray<T>, size: number[]): void;
+/**
+ * Validate whether the source of the index matches the size of the Array
+ * @param {Array | Matrix} value    Array to be validated
+ * @param {Index} index  Index with the source information to validate
+ * @throws DimensionError
+ */
+export declare function validateIndexSourceSize(value: unknown[] | Matrix, index: Index): void;
+/**
+ * Test whether index is an integer number with index >= 0 and index < length
+ * when length is provided
+ * @param {number} index    Zero-based index
+ * @param {number} [length] Length of the array
+ */
+export declare function validateIndex(index: number | undefined, length?: number): void;
+/**
+ * Test if an index has empty values
+ * @param {Index} index    Zero-based index
+ */
+export declare function isEmptyIndex(index: Index): boolean;
+/**
+ * Resize a multi dimensional array. The resized array is returned.
+ * @param {Array | number} array         Array to be resized
+ * @param {number[]} size Array with the size of each dimension
+ * @param {*} [defaultValue=0]  Value to be filled in new entries,
+ *                              zero by default. Specify for example `null`,
+ *                              to clearly see entries that are not explicitly
+ *                              set.
+ * @return {Array} array         The resized array
+ */
+export declare function resize<T = unknown>(array: T | T[] | NestedArray<T>, size: number[], defaultValue?: T): NestedArray<T>;
+/**
+ * Re-shape a multi dimensional array to fit the specified dimensions
+ * @param {Array} array           Array to be reshaped
+ * @param {number[]} sizes        List of sizes for each dimension
+ * @returns {Array}               Array whose data has been formatted to fit the
+ *                                specified dimensions
+ *
+ * @throws {DimensionError}       If the product of the new dimension sizes does
+ *                                not equal that of the old ones
+ */
+export declare function reshape<T = unknown>(array: NestedArray<T>, sizes: number[]): NestedArray<T>;
+/**
+ * Replaces the wildcard -1 in the sizes array.
+ * @param {number[]} sizes  List of sizes for each dimension. At most one wildcard.
+ * @param {number} currentLength  Number of elements in the array.
+ * @throws {Error}                If more than one wildcard or unable to replace it.
+ * @returns {number[]}      The sizes array with wildcard replaced.
+ */
+export declare function processSizesWildcard(sizes: number[], currentLength: number): number[];
+/**
+ * Squeeze a multi dimensional array
+ * @param {Array} array
+ * @param {Array} [size]
+ * @returns {Array} returns the array itself
+ */
+export declare function squeeze<T>(array: NestedArray<T>, size?: number[]): T | NestedArray<T>;
+/**
+ * Unsqueeze a multi dimensional array: add dimensions when missing
+ *
+ * Parameter `size` will be mutated to match the new, unsqueezed matrix size.
+ *
+ * @param {Array} array
+ * @param {number} dims       Desired number of dimensions of the array
+ * @param {number} [outer]    Number of outer dimensions to be added
+ * @param {Array} [size] Current size of array.
+ * @returns {Array} returns the array itself
+ * @private
+ */
+export declare function unsqueeze<T>(array: NestedArray<T>, dims: number, outer?: number, size?: number[]): NestedArray<T>;
+/**
+ * Flatten a multi dimensional array, put all elements in a one dimensional
+ * array
+ * @param {Array} array   A multi dimensional array
+ * @param {boolean} isRectangular Optional. If the array is rectangular (not jagged)
+ * @return {Array}        The flattened array (1 dimensional)
+ */
+export declare function flatten<T>(array: NestedArray<T>, isRectangular?: boolean): T[];
+/**
+ * A safe map
+ * @param {Array} array
+ * @param {function} callback
+ */
+export declare function map<T, U>(array: T[], callback: (value: T, index: number, array: T[]) => U): U[];
+/**
+ * A safe forEach
+ * @param {Array} array
+ * @param {function} callback
+ */
+export declare function forEach<T>(array: T[], callback: (value: T, index: number, array: T[]) => void): void;
+/**
+ * A safe filter
+ * @param {Array} array
+ * @param {function} callback
+ */
+export declare function filter<T>(array: T[], callback: (value: T, index: number, array: T[]) => boolean): T[];
+/**
+ * Filter values in an array given a regular expression
+ * @param {Array} array
+ * @param {RegExp} regexp
+ * @return {Array} Returns the filtered array
+ * @private
+ */
+export declare function filterRegExp(array: string[], regexp: RegExp): string[];
+/**
+ * A safe join
+ * @param {Array} array
+ * @param {string} separator
+ */
+export declare function join<T>(array: T[], separator: string): string;
+/**
+ * Assign a numeric identifier to every element of a sorted array
+ * @param {Array} a  An array
+ * @return {Array} An array of objects containing the original value and its identifier
+ */
+export declare function identify<T>(a: T[]): IdentifiedValue<T>[];
+/**
+ * Remove the numeric identifier from the elements
+ * @param {array} a  An array
+ * @return {array} An array of values without identifiers
+ */
+export declare function generalize<T>(a: IdentifiedValue<T>[]): T[];
+/**
+ * Check the datatype of a given object
+ * This is a low level implementation that should only be used by
+ * parent Matrix classes such as SparseMatrix or DenseMatrix
+ * This method does not validate Array Matrix shape
+ * @param {Array} array
+ * @param {function} typeOf   Callback function to use to determine the type of a value
+ * @return {string}
+ */
+export declare function getArrayDataType(array: unknown[], typeOf: (value: unknown) => string): string | undefined;
+/**
+ * Return the last item from an array
+ * @param {Array} array
+ * @returns {*}
+ */
+export declare function last<T>(array: T[]): T;
+/**
+ * Get all but the last element of array.
+ *
+ * KNOWN DIVERGENCE (Bucket B slice 2): only `expression/src/utils/array.ts` had
+ * this; `functions/src/utils/array.ts` never defined it, and it was dead code
+ * even in expression (unused outside its own definition). Re-exported from
+ * expression's shim only — see the module header.
+ * @param {Array} array
+ * @returns {Array}
+ */
+export declare function initial<T>(array: T[]): T[];
+/**
+ * Concatenates many arrays in the specified direction
+ * @param {...Array} arrays All the arrays to concatenate
+ * @param {number} concatDim The dimension on which to concatenate (zero-based)
+ * @returns {Array}
+ */
+export declare function concat<T>(...args: [...NestedArray<T>[], number]): NestedArray<T>[];
+/**
+ * Receives two or more sizes and gets the broadcasted size for both.
+ * @param  {...number[]} sizes Sizes to broadcast together
+ * @returns {number[]} The broadcasted size
+ */
+export declare function broadcastSizes(...sizes: number[][]): number[];
+/**
+ * Checks if it's possible to broadcast a size to another size
+ * @param {number[]} size The size of the array to check
+ * @param {number[]} toSize The size of the array to validate if it can be broadcasted to
+ */
+export declare function checkBroadcastingRules(size: number[], toSize: number[]): void;
+/**
+ * Broadcasts a single array to a certain size
+ * @param {Array} array Array to be broadcasted
+ * @param {number[]} toSize Size to broadcast the array
+ * @returns {Array} The broadcasted array
+ */
+export declare function broadcastTo<T>(array: NestedArray<T>, toSize: number[]): NestedArray<T>;
+/**
+ * Broadcasts arrays and returns the broadcasted arrays in an array
+ * @param  {...Array | any} arrays
+ * @returns {Array[]} The broadcasted arrays
+ */
+export declare function broadcastArrays<T>(...arrays: NestedArray<T>[]): NestedArray<T>[];
+/**
+ * Stretches a matrix up to a certain size in a certain dimension
+ * @param {Array} arrayToStretch
+ * @param {number[]} sizeToStretch
+ * @param {number} dimToStretch
+ * @returns {Array} The stretched array
+ */
+export declare function stretch<T>(arrayToStretch: NestedArray<T>, sizeToStretch: number, dimToStretch: number): NestedArray<T>;
+/**
+ * Retrieves a single element from an array given an index.
+ *
+ * @param {Array} array - The array from which to retrieve the value.
+ * @param {Array<number>} index - An array of indices specifying the position of the desired element in each dimension.
+ * @returns {*} - The value at the specified position in the array.
+ *
+ * @example
+ * const arr = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]];
+ * const index = [1, 0, 1];
+ * console.log(get(arr, index)); // 6
+ */
+export declare function get<T>(array: NestedArray<T>, index: number[]): T;
+/**
+ * Recursively maps over each element of nested array using a provided callback function.
+ *
+ * @param {Array} array - The array to be mapped.
+ * @param {Function} callback - The function to execute on each element, taking three arguments:
+ *   - `value` (any): The current element being processed in the array.
+ *   - `index` (Array<number>): The index of the current element being processed in the array.
+ *   - `array` (Array): The array `deepMap` was called upon.
+ * @param {boolean} [skipIndex=false] - If true, the callback function is called with only the value.
+ * @returns {Array} A new array with each element being the result of the callback function.
+ */
+export declare function deepMap<T, U>(array: NestedArray<T>, callback: ((value: T, index: number[], array: NestedArray<T>) => U) | ((value: T) => U), skipIndex?: boolean): NestedArray<U>;
+/**
+ * Recursively iterates over each element in a multi-dimensional array and applies a callback function.
+ *
+ * @param {Array} array - The multi-dimensional array to iterate over.
+ * @param {Function} callback - The function to execute for each element. It receives three arguments:
+ *   - {any} value: The current element being processed in the array.
+ *   - {Array<number>} index: The index of the current element in each dimension.
+ *   - {Array} array: The original array being processed.
+ * @param {boolean} [skipIndex=false] - If true, the callback function is called with only the value.
+ */
+export declare function deepForEach<T>(array: NestedArray<T>, callback: ((value: T, index: number[], array: NestedArray<T>) => void) | ((value: T) => void), skipIndex?: boolean): void;
+/**
+ * Deep clones a multidimensional array
+ * @param {Array} array
+ * @returns {Array} cloned array
+ */
+export declare function clone<T>(array: T[]): T[];
+//# sourceMappingURL=array.d.ts.map

package/dist/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.ts"],"names":[],"mappings":"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"}

package/dist/bignumber-formatter.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Structural contract for the BigNumber values handled by this formatter.
+ * Captures exactly the methods/properties used here. The configured BigNumber
+ * implementation (e.g. decimal.js) provides these; the project's `BigNumber`
+ * type alias points at a minimal local Decimal that does not declare them all,
+ * so we model the runtime contract explicitly.
+ */
+export interface BigNumberValue {
+    e: number;
+    constructor: new (value: number | string) => BigNumberValue;
+    isFinite(): boolean;
+    isNaN(): boolean;
+    isZero(): boolean;
+    isInteger(): boolean;
+    gt(other: number | BigNumberValue): boolean;
+    greaterThan(other: number | BigNumberValue): boolean;
+    lessThan(other: number | BigNumberValue): boolean;
+    add(other: number | BigNumberValue): BigNumberValue;
+    sub(other: number | BigNumberValue): BigNumberValue;
+    mul(other: number | BigNumberValue): BigNumberValue;
+    pow(exp: number | BigNumberValue): BigNumberValue;
+    toNumber(): number;
+    toFixed(places?: number): string;
+    toExponential(places?: number): string;
+    toPrecision(sd?: number): string;
+    toSignificantDigits(sd?: number): BigNumberValue;
+    toBinary(): string;
+    toOctal(): string;
+    toHexadecimal(): string;
+}
+/**
+ * Convert a BigNumber to a formatted string representation.
+ *
+ * Syntax:
+ *
+ *    format(value)
+ *    format(value, options)
+ *    format(value, precision)
+ *    format(value, fn)
+ *
+ * Where:
+ *
+ *    {number} value   The value to be formatted
+ *    {Object} options An object with formatting options. Available options:
+ *                     {string} notation
+ *                         Number notation. Choose from:
+ *                         'fixed'          Always use regular number notation.
+ *                                          For example '123.40' and '14000000'
+ *                         'exponential'    Always use exponential notation.
+ *                                          For example '1.234e+2' and '1.4e+7'
+ *                         'auto' (default) Regular number notation for numbers
+ *                                          having an absolute value between
+ *                                          `lower` and `upper` bounds, and uses
+ *                                          exponential notation elsewhere.
+ *                                          Lower bound is included, upper bound
+ *                                          is excluded.
+ *                                          For example '123.4' and '1.4e7'.
+ *                         'bin', 'oct, or
+ *                         'hex'            Format the number using binary, octal,
+ *                                          or hexadecimal notation.
+ *                                          For example '0b1101' and '0x10fe'.
+ *                     {number} wordSize    The word size in bits to use for formatting
+ *                                          in binary, octal, or hexadecimal notation.
+ *                                          To be used only with 'bin', 'oct', or 'hex'
+ *                                          values for 'notation' option. When this option
+ *                                          is defined the value is formatted as a signed
+ *                                          twos complement integer of the given word size
+ *                                          and the size suffix is appended to the output.
+ *                                          For example
+ *                                          format(-1, {notation: 'hex', wordSize: 8}) === '0xffi8'.
+ *                                          Default value is undefined.
+ *                     {number} precision   A number between 0 and 16 to round
+ *                                          the digits of the number.
+ *                                          In case of notations 'exponential',
+ *                                          'engineering', and 'auto',
+ *                                          `precision` defines the total
+ *                                          number of significant digits returned.
+ *                                          In case of notation 'fixed',
+ *                                          `precision` defines the number of
+ *                                          significant digits after the decimal
+ *                                          point.
+ *                                          `precision` is undefined by default.
+ *                     {number} lowerExp    Exponent determining the lower boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `-3`.
+ *                     {number} upperExp    Exponent determining the upper boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `5`.
+ *    {Function} fn    A custom formatting function. Can be used to override the
+ *                     built-in notations. Function `fn` is called with `value` as
+ *                     parameter and must return a string. Is useful for example to
+ *                     format all values inside a matrix in a particular way.
+ *
+ * Examples:
+ *
+ *    format(6.4)                                        // '6.4'
+ *    format(1240000)                                    // '1.24e6'
+ *    format(1/3)                                        // '0.3333333333333333'
+ *    format(1/3, 3)                                     // '0.333'
+ *    format(21385, 2)                                   // '21000'
+ *    format(12e8, {notation: 'fixed'})                  // returns '1200000000'
+ *    format(2.3,    {notation: 'fixed', precision: 4})  // returns '2.3000'
+ *    format(52.8,   {notation: 'exponential'})          // returns '5.28e+1'
+ *    format(12400,  {notation: 'engineering'})          // returns '12.400e+3'
+ *
+ * @param {BigNumber} value
+ * @param {Object | Function | number | BigNumber} [options]
+ * @return {string} str The formatted value
+ */
+export declare function format(value: unknown, options?: unknown): string;
+/**
+ * Format a BigNumber in engineering notation. Like '1.23e+6', '2.3e+0', '3.500e-3'
+ * @param {BigNumber} value
+ * @param {number} [precision]        Optional number of significant figures to return.
+ */
+export declare function toEngineering(value: BigNumberValue, precision?: number): string;
+/**
+ * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
+ * @param {BigNumber} value
+ * @param {number} [precision]  Number of digits in formatted output.
+ *                              If not provided, the maximum available digits
+ *                              is used.
+ * @returns {string} str
+ */
+export declare function toExponential(value: BigNumberValue, precision?: number): string;
+/**
+ * Format a number with fixed notation.
+ * @param {BigNumber} value
+ * @param {number} [precision=undefined] Optional number of decimals after the
+ *                                       decimal point. Undefined by default.
+ */
+export declare function toFixed(value: BigNumberValue, precision?: number): string;
+//# sourceMappingURL=bignumber-formatter.d.ts.map

package/dist/bignumber-formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bignumber-formatter.d.ts","sourceRoot":"","sources":["../src/bignumber-formatter.ts"],"names":[],"mappings":"AAqBA;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,KAAK,KAAK,EAAE,MAAM,GAAG,MAAM,KAAK,cAAc,CAAC;IAC5D,QAAQ,IAAI,OAAO,CAAC;IACpB,KAAK,IAAI,OAAO,CAAC;IACjB,MAAM,IAAI,OAAO,CAAC;IAClB,SAAS,IAAI,OAAO,CAAC;IACrB,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,OAAO,CAAC;IAC5C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,OAAO,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,OAAO,CAAC;IAClD,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;IACpD,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;IACpD,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;IACpD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;IAClD,QAAQ,IAAI,MAAM,CAAC;IACnB,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvC,WAAW,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,mBAAmB,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC;IACjD,QAAQ,IAAI,MAAM,CAAC;IACnB,OAAO,IAAI,MAAM,CAAC;IAClB,aAAa,IAAI,MAAM,CAAC;CACzB;AA2CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAkGhE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAe/E;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAM/E;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAEzE"}