@pawells/math-extended 1.1.1 → 3.0.0

package/build/matrices/arithmetic.d.ts

@@ -1,5 +1,5 @@
-import { IMatrix, IMatrix1, IMatrix2, IMatrix3, IMatrix4, TMatrixResult } from './types.js';
-import { TVector, TVector2, TVector3, TVector4 } from '../vectors/types.js';
+import type { TMatrix, TMatrix1, TMatrix2, TMatrix3, TMatrix4, TMatrixResult } from './types.js';
+import type { TVector, TVector2, TVector3, TVector4 } from '../vectors/types.js';
 /**
  * Performs element-wise addition of two matrices.
  *
@@ -19,7 +19,7 @@ import { TVector, TVector2, TVector3, TVector4 } from '../vectors/types.js';
  * **Time Complexity:** O(m×n) where m and n are the matrix dimensions
  * **Space Complexity:** O(m×n) for the result matrix
  *
- * @template T - The matrix type extending IMatrix interface
+ * @template T - The matrix type extending TMatrix interface
  * @param a - First matrix (addend) - must have same dimensions as b
  * @param b - Second matrix (addend) - must have same dimensions as a
  * @returns {TMatrixResult<T>} A new matrix where each element is the sum of corresponding elements
@@ -27,19 +27,19 @@ import { TVector, TVector2, TVector3, TVector4 } from '../vectors/types.js';
  *
  * @example
  * ```typescript
+ * ```typescript
  * // Adding 2×2 matrices
  * MatrixAdd([[1, 2], [3, 4]], [[5, 6], [7, 8]]) // Returns [[6, 8], [10, 12]]
- *
  * // Adding 1×3 row vectors
  * MatrixAdd([[1, 2, 3]], [[4, 5, 6]]) // Returns [[5, 7, 9]]
- *
  * // Type-safe matrix addition with specific matrix types
- * const matrixA: IMatrix2 = [[1, 2], [3, 4]];
- * const matrixB: IMatrix2 = [[5, 6], [7, 8]];
- * const result: IMatrix2 = MatrixAdd(matrixA, matrixB);
+ * const matrixA: TMatrix2 = [[1, 2], [3, 4]];
+ * const matrixB: TMatrix2 = [[5, 6], [7, 8]];
+ * const result: TMatrix2 = MatrixAdd(matrixA, matrixB);
+ * ```
  * ```
  */
-export declare function MatrixAdd<T extends IMatrix>(a: T, b: T): TMatrixResult<T>;
+export declare function MatrixAdd<T extends TMatrix>(a: T, b: T): TMatrixResult<T>;
 /**
  * Performs element-wise subtraction of two matrices (a - b).
  *
@@ -59,7 +59,7 @@ export declare function MatrixAdd<T extends IMatrix>(a: T, b: T): TMatrixResult<
  * **Time Complexity:** O(m×n) where m and n are the matrix dimensions
  * **Space Complexity:** O(m×n) for the result matrix
  *
- * @template T - The matrix type extending IMatrix interface
+ * @template T - The matrix type extending TMatrix interface
  * @param a - First matrix (minuend) - the matrix being subtracted from
  * @param b - Second matrix (subtrahend) - the matrix being subtracted
  * @returns {TMatrixResult<T>} A new matrix where each element is the difference of corresponding elements
@@ -67,18 +67,18 @@ export declare function MatrixAdd<T extends IMatrix>(a: T, b: T): TMatrixResult<
  *
  * @example
  * ```typescript
+ * ```typescript
  * // Subtracting 2×2 matrices
  * MatrixSubtract([[10, 8], [6, 4]], [[3, 2], [1, 1]]) // Returns [[7, 6], [5, 3]]
- *
  * // Order matters: A - B ≠ B - A
  * MatrixSubtract([[1, 2]], [[3, 4]]) // Returns [[-2, -2]]
  * MatrixSubtract([[3, 4]], [[1, 2]]) // Returns [[2, 2]]
- *
  * // Self-subtraction produces zero matrix
  * MatrixSubtract([[5, 6]], [[5, 6]]) // Returns [[0, 0]]
  * ```
+ * ```
  */
-export declare function MatrixSubtract<T extends IMatrix>(a: T, b: T): TMatrixResult<T>;
+export declare function MatrixSubtract<T extends TMatrix>(a: T, b: T): TMatrixResult<T>;
 /**
  * Performs matrix multiplication with comprehensive type-safe overloads for matrices, vectors, and scalars.
  *
@@ -89,24 +89,24 @@ export declare function MatrixSubtract<T extends IMatrix>(a: T, b: T): TMatrixRe
  *
  * **Type-Safe Overloads:**
  * - **Scalar Multiplication:**
- *   - `IMatrix1 × number → IMatrix1` (1×1 matrix scalar multiplication)
- *   - `IMatrix2 × number → IMatrix2` (2×2 matrix scalar multiplication)
- *   - `IMatrix3 × number → IMatrix3` (3×3 matrix scalar multiplication)
- *   - `IMatrix4 × number → IMatrix4` (4×4 matrix scalar multiplication)
- *   - `IMatrix × number → IMatrix` (general matrix scalar multiplication)
+ *   - `TMatrix1 × number → TMatrix1` (1×1 matrix scalar multiplication)
+ *   - `TMatrix2 × number → TMatrix2` (2×2 matrix scalar multiplication)
+ *   - `TMatrix3 × number → TMatrix3` (3×3 matrix scalar multiplication)
+ *   - `TMatrix4 × number → TMatrix4` (4×4 matrix scalar multiplication)
+ *   - `TMatrix × number → TMatrix` (general matrix scalar multiplication)
  *
  * - **Vector Multiplication:**
- *   - `IMatrix2 × TVector2 → TVector2` (2×2 matrix × 2D vector)
- *   - `IMatrix3 × TVector3 → TVector3` (3×3 matrix × 3D vector)
- *   - `IMatrix4 × TVector4 → TVector4` (4×4 matrix × 4D vector)
- *   - `IMatrix × TVector → TVector` (general matrix × vector)
+ *   - `TMatrix2 × TVector2 → TVector2` (2×2 matrix × 2D vector)
+ *   - `TMatrix3 × TVector3 → TVector3` (3×3 matrix × 3D vector)
+ *   - `TMatrix4 × TVector4 → TVector4` (4×4 matrix × 4D vector)
+ *   - `TMatrix × TVector → TVector` (general matrix × vector)
  *
  * - **Matrix Multiplication:**
- *   - `IMatrix1 × IMatrix1 → IMatrix1` (1×1 matrix multiplication)
- *   - `IMatrix2 × IMatrix2 → IMatrix2` (2×2 matrix multiplication)
- *   - `IMatrix3 × IMatrix3 → IMatrix3` (3×3 matrix multiplication)
- *   - `IMatrix4 × IMatrix4 → IMatrix4` (4×4 matrix multiplication)
- *   - `IMatrix × IMatrix → IMatrix` (general matrix multiplication)
+ *   - `TMatrix1 × TMatrix1 → TMatrix1` (1×1 matrix multiplication)
+ *   - `TMatrix2 × TMatrix2 → TMatrix2` (2×2 matrix multiplication)
+ *   - `TMatrix3 × TMatrix3 → TMatrix3` (3×3 matrix multiplication)
+ *   - `TMatrix4 × TMatrix4 → TMatrix4` (4×4 matrix multiplication)
+ *   - `TMatrix × TMatrix → TMatrix` (general matrix multiplication)
  *
  * **Operation Types:**
  * - **Matrix × Scalar:** Element-wise multiplication by scalar value
@@ -126,7 +126,7 @@ export declare function MatrixSubtract<T extends IMatrix>(a: T, b: T): TMatrixRe
  *
  * @param a - First matrix (left operand) with dimensions m×n
  * @param b - Second operand: matrix (n×p), vector (n elements), or scalar number
- * @returns {IMatrix | TVector} The product result:
+ * @returns {TMatrix | TVector} The product result:
  *   - For scalar: m×n matrix with each element multiplied by scalar
  *   - For vector: m×1 column vector matrix
  *   - For matrix: m×p product matrix
@@ -134,51 +134,47 @@ export declare function MatrixSubtract<T extends IMatrix>(a: T, b: T): TMatrixRe
  *
  * @example
  * ```typescript
+ * ```typescript
  * // Type-safe scalar multiplication with specific matrix types
- * const matrix2: IMatrix2 = [[1, 2], [3, 4]];
- * const scalar2Result: IMatrix2 = MatrixMultiply(matrix2, 2); // [[2, 4], [6, 8]]
- *
- * const matrix3: IMatrix3 = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
- * const scalar3Result: IMatrix3 = MatrixMultiply(matrix3, 5); // Identity × 5
- *
+ * const matrix2: TMatrix2 = [[1, 2], [3, 4]];
+ * const scalar2Result: TMatrix2 = MatrixMultiply(matrix2, 2); // [[2, 4], [6, 8]]
+ * const matrix3: TMatrix3 = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
+ * const scalar3Result: TMatrix3 = MatrixMultiply(matrix3, 5); // Identity × 5
  * // Type-safe vector multiplication with specific matrix/vector types
- * const matrix2x2: IMatrix2 = [[1, 2], [3, 4]];
+ * const matrix2x2: TMatrix2 = [[1, 2], [3, 4]];
  * const vector2: TVector2 = [5, 6];
  * const vectorResult: TVector2 = MatrixMultiply(matrix2x2, vector2); // [17, 39]
- *
- * const matrix4x4: IMatrix4 = [[1,0,0,0], [0,1,0,0], [0,0,1,0], [0,0,0,1]];
+ * const matrix4x4: TMatrix4 = [[1,0,0,0], [0,1,0,0], [0,0,1,0], [0,0,0,1]];
  * const vector4: TVector4 = [1, 2, 3, 4];
  * const vector4Result: TVector4 = MatrixMultiply(matrix4x4, vector4); // [1, 2, 3, 4]
- *
  * // Type-safe matrix multiplication with specific matrix types
- * const matrixA: IMatrix2 = [[1, 2], [3, 4]];
- * const matrixB: IMatrix2 = [[5, 6], [7, 8]];
- * const matrixResult: IMatrix2 = MatrixMultiply(matrixA, matrixB); // [[19, 22], [43, 50]]
- *
+ * const matrixA: TMatrix2 = [[1, 2], [3, 4]];
+ * const matrixB: TMatrix2 = [[5, 6], [7, 8]];
+ * const matrixResult: TMatrix2 = MatrixMultiply(matrixA, matrixB); // [[19, 22], [43, 50]]
  * // General matrix operations (fallback to generic types)
  * MatrixMultiply([[1, 2]], [[3], [4]]) // Returns [[11]]
  * MatrixMultiply([[1], [2]], [[3, 4]]) // Returns [[3, 4], [6, 8]]
- *
  * // Type detection is automatic - no need to specify operation type
  * const scalarResult = MatrixMultiply(matrixA, 5);        // Scalar multiplication
  * const vectorResult2 = MatrixMultiply(matrixA, vector2);  // Vector multiplication
  * const matrixResult2 = MatrixMultiply(matrixA, matrixB); // Matrix multiplication
  * ```
+ * ```
  */
-export declare function MatrixMultiply(a: IMatrix1, b: number): IMatrix1;
-export declare function MatrixMultiply(a: IMatrix2, b: number): IMatrix2;
-export declare function MatrixMultiply(a: IMatrix3, b: number): IMatrix3;
-export declare function MatrixMultiply(a: IMatrix4, b: number): IMatrix4;
-export declare function MatrixMultiply(a: IMatrix2, b: TVector2): TVector2;
-export declare function MatrixMultiply(a: IMatrix3, b: TVector3): TVector3;
-export declare function MatrixMultiply(a: IMatrix4, b: TVector4): TVector4;
-export declare function MatrixMultiply(a: IMatrix1, b: IMatrix1): IMatrix1;
-export declare function MatrixMultiply(a: IMatrix2, b: IMatrix2): IMatrix2;
-export declare function MatrixMultiply(a: IMatrix3, b: IMatrix3): IMatrix3;
-export declare function MatrixMultiply(a: IMatrix4, b: IMatrix4): IMatrix4;
-export declare function MatrixMultiply(a: IMatrix, b: TVector): TVector;
-export declare function MatrixMultiply(a: IMatrix, b: IMatrix): IMatrix;
-export declare function MatrixMultiply(a: IMatrix, b: number): IMatrix;
+export declare function MatrixMultiply(a: TMatrix1, b: number): TMatrix1;
+export declare function MatrixMultiply(a: TMatrix2, b: number): TMatrix2;
+export declare function MatrixMultiply(a: TMatrix3, b: number): TMatrix3;
+export declare function MatrixMultiply(a: TMatrix4, b: number): TMatrix4;
+export declare function MatrixMultiply(a: TMatrix2, b: TVector2): TVector2;
+export declare function MatrixMultiply(a: TMatrix3, b: TVector3): TVector3;
+export declare function MatrixMultiply(a: TMatrix4, b: TVector4): TVector4;
+export declare function MatrixMultiply(a: TMatrix1, b: TMatrix1): TMatrix1;
+export declare function MatrixMultiply(a: TMatrix2, b: TMatrix2): TMatrix2;
+export declare function MatrixMultiply(a: TMatrix3, b: TMatrix3): TMatrix3;
+export declare function MatrixMultiply(a: TMatrix4, b: TMatrix4): TMatrix4;
+export declare function MatrixMultiply(a: TMatrix, b: TVector): TVector;
+export declare function MatrixMultiply(a: TMatrix, b: TMatrix): TMatrix;
+export declare function MatrixMultiply(a: TMatrix, b: number): TMatrix;
 /**
  * Extracts a rectangular submatrix from a larger matrix.
  *
@@ -219,28 +215,24 @@ export declare function MatrixMultiply(a: IMatrix, b: number): IMatrix;
  * @param startRow - Starting row index (0-based, inclusive) — note reversed order
  * @param width - Number of columns to extract (must be positive)
  * @param height - Number of rows to extract (must be positive)
- * @returns {IMatrix} The extracted submatrix with dimensions height×width
+ * @returns {TMatrix} The extracted submatrix with dimensions height×width
  * @throws {Error} If extraction bounds exceed matrix dimensions or contain invalid values
  * @example
  * ```typescript
+ * ```typescript
  * const matrix = [
  *   [1,  2,  3,  4],
  *   [5,  6,  7,  8],
  *   [9, 10, 11, 12]
  * ]; // 3×4 matrix
- *
  * // Extract 2×2 submatrix from top-left corner
  * MatrixSubmatrix(matrix, 0, 0, 2, 2) // Returns [[1, 2], [5, 6]]
- *
  * // Extract 2×2 submatrix from center-right region
  * MatrixSubmatrix(matrix, 2, 1, 2, 2) // Returns [[7, 8], [11, 12]]
- *
  * // Extract single column (column vector)
  * MatrixSubmatrix(matrix, 1, 0, 1, 3) // Returns [[2], [6], [10]]
- *
  * // Extract single row (row vector)
  * MatrixSubmatrix(matrix, 0, 1, 4, 1) // Returns [[5, 6, 7, 8]]
- *
  * // Block matrix partitioning for algorithms
  * const large = MatrixCreate(8, 8); // 8×8 matrix
  * const topLeft = MatrixSubmatrix(large, 0, 0, 4, 4);     // Top-left 4×4 block
@@ -248,8 +240,9 @@ export declare function MatrixMultiply(a: IMatrix, b: number): IMatrix;
  * const bottomLeft = MatrixSubmatrix(large, 0, 4, 4, 4);  // Bottom-left 4×4 block
  * const bottomRight = MatrixSubmatrix(large, 4, 4, 4, 4); // Bottom-right 4×4 block
  * ```
+ * ```
  */
-export declare function MatrixSubmatrix(matrix: IMatrix, startCol: number, startRow: number, width: number, height: number): IMatrix;
+export declare function MatrixSubmatrix(matrix: TMatrix, startCol: number, startRow: number, width: number, height: number): TMatrix;
 /**
  * Pads a matrix with zeros to reach the specified dimensions.
  *
@@ -288,12 +281,12 @@ export declare function MatrixSubmatrix(matrix: IMatrix, startCol: number, start
  * @param matrix - Source matrix to pad
  * @param newRows - Target number of rows (must be ≥ current rows)
  * @param newCols - Target number of columns (must be ≥ current columns)
- * @returns {IMatrix} The padded matrix with dimensions newRows×newCols
+ * @returns {TMatrix} The padded matrix with dimensions newRows×newCols
  * @throws {Error} If new dimensions are smaller than current dimensions
  * @example
  * ```typescript
+ * ```typescript
  * const matrix = [[1, 2], [3, 4]]; // 2×2 matrix
- *
  * // Pad to 4×4 matrix (symmetric padding)
  * MatrixPad(matrix, 4, 4)
  * // Returns:
@@ -301,28 +294,25 @@ export declare function MatrixSubmatrix(matrix: IMatrix, startCol: number, start
  * //  [3, 4, 0, 0],
  * //  [0, 0, 0, 0],
  * //  [0, 0, 0, 0]]
- *
  * // Pad to 3×4 matrix (asymmetric padding)
  * MatrixPad(matrix, 3, 4)
  * // Returns:
  * // [[1, 2, 0, 0],
  * //  [3, 4, 0, 0],
  * //  [0, 0, 0, 0]]
- *
  * // Prepare for power-of-2 algorithm (e.g., FFT-based convolution)
  * const data = [[1, 2, 3], [4, 5, 6]]; // 2×3 matrix
  * const powerOf2 = MatrixPad(data, 4, 4); // Pad to 4×4 for FFT
- *
  * // Batch size alignment in machine learning
  * const features = MatrixCreate(7, 10); // 7 samples, 10 features
  * const aligned = MatrixPad(features, 8, 10); // Align to batch size 8
- *
  * // Image border padding for convolution
  * const image = MatrixCreate(28, 28); // 28×28 image
  * const padded = MatrixPad(image, 32, 32); // Add border for valid convolution
  * ```
+ * ```
  */
-export declare function MatrixPad(matrix: IMatrix, newRows: number, newCols: number): IMatrix;
+export declare function MatrixPad(matrix: TMatrix, newRows: number, newCols: number): TMatrix;
 /**
  * Combines four square submatrices into a single matrix (2×2 block structure).
  *
@@ -371,31 +361,29 @@ export declare function MatrixPad(matrix: IMatrix, newRows: number, newCols: num
  * @param c12 - Top-right quadrant (upper-right block)
  * @param c21 - Bottom-left quadrant (lower-left block)
  * @param c22 - Bottom-right quadrant (lower-right block)
- * @returns {IMatrix} The combined matrix with dimensions 2n×2n (where each input is n×n)
+ * @returns {TMatrix} The combined matrix with dimensions 2n×2n (where each input is n×n)
  * @throws {Error} If quadrants have mismatched dimensions or invalid values
  *
  * @example
  * ```typescript
+ * ```typescript
  * // Basic 2×2 quadrant combination
  * const topLeft = [[1, 2], [3, 4]];
  * const topRight = [[5, 6], [7, 8]];
  * const bottomLeft = [[9, 10], [11, 12]];
  * const bottomRight = [[13, 14], [15, 16]];
- *
  * MatrixCombine(topLeft, topRight, bottomLeft, bottomRight)
  * // Returns:
  * // [[1,  2,  5,  6],
  * //  [3,  4,  7,  8],
  * //  [9, 10, 13, 14],
  * //  [11,12, 15, 16]]
- *
  * // Strassen algorithm result reconstruction
  * const m1 = computeStrassenProduct1(); // Computed Strassen intermediate results
  * const m2 = computeStrassenProduct2();
  * const m3 = computeStrassenProduct3();
  * const m4 = computeStrassenProduct4();
  * const finalResult = MatrixCombine(m1, m2, m3, m4); // Assemble final result
- *
  * // Image processing: combining processed quadrants
  * const processedTopLeft = processImageQuadrant(imageTopLeft);
  * const processedTopRight = processImageQuadrant(imageTopRight);
@@ -406,6 +394,7 @@ export declare function MatrixPad(matrix: IMatrix, newRows: number, newCols: num
  *   processedBottomLeft, processedBottomRight
  * );
  * ```
+ * ```
  */
-export declare function MatrixCombine(c11: IMatrix, c12: IMatrix, c21: IMatrix, c22: IMatrix): IMatrix;
+export declare function MatrixCombine(c11: TMatrix, c12: TMatrix, c21: TMatrix, c22: TMatrix): TMatrix;
 //# sourceMappingURL=arithmetic.d.ts.map

package/build/matrices/arithmetic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmetic.d.ts","sourceRoot":"","sources":["../../src/matrices/arithmetic.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"arithmetic.d.ts","sourceRoot":"","sources":["../../src/matrices/arithmetic.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACjG,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAiCzE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CA8B9E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AAEH,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;AAEjE,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;AAEjE,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;AAEjE,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;AAEjE,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;AAEnE,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;AAEnE,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;AAEnE,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;AAEnE,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;AAEnE,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;AAEnE,wBAAgB,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;AAEnE,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;AAEhE,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;AAEhE,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;AAitB/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAiB3H;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAkBpF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CAyD7F"}