@elaraai/east-py-datascience 0.0.2-beta.8 → 0.0.2-beta.81

package/dist/{ngboost → src/ngboost}/ngboost.js

@@ -62,13 +62,13 @@ export const NGBoostPredictConfigType = StructType({
  */
 export const NGBoostPredictResultType = StructType({
     /** Point predictions (mean) */
-    predictions: VectorType,
+    predictions: VectorType(FloatType),
     /** Standard deviation */
-    std: OptionType(VectorType),
+    std: OptionType(VectorType(FloatType)),
     /** Lower confidence interval */
-    lower: OptionType(VectorType),
+    lower: OptionType(VectorType(FloatType)),
     /** Upper confidence interval */
-    upper: OptionType(VectorType),
+    upper: OptionType(VectorType(FloatType)),
 });
 // ============================================================================
 // Model Blob Types
@@ -98,7 +98,7 @@ export const NGBoostModelBlobType = VariantType({
  * @param config - NGBoost configuration
  * @returns Model blob containing trained regressor
  */
-export const ngboost_train_regressor = East.platform("ngboost_train_regressor", [MatrixType, VectorType, NGBoostConfigType], NGBoostModelBlobType);
+export const ngboost_train_regressor = East.platform("ngboost_train_regressor", [MatrixType(FloatType), VectorType(FloatType), NGBoostConfigType], NGBoostModelBlobType);
 /**
  * Make point predictions (mean) with a trained NGBoost regressor.
  *
@@ -106,7 +106,7 @@ export const ngboost_train_regressor = East.platform("ngboost_train_regressor",
  * @param X - Feature matrix
  * @returns Predicted values (mean of predictive distribution)
  */
-export const ngboost_predict = East.platform("ngboost_predict", [NGBoostModelBlobType, MatrixType], VectorType);
+export const ngboost_predict = East.platform("ngboost_predict", [NGBoostModelBlobType, MatrixType(FloatType)], VectorType(FloatType));
 /**
  * Get predictions with full uncertainty from NGBoost regressor.
  *
@@ -117,7 +117,7 @@ export const ngboost_predict = East.platform("ngboost_predict", [NGBoostModelBlo
  * @param config - Prediction configuration (confidence level)
  * @returns Predictions with uncertainty estimates
  */
-export const ngboost_predict_dist = East.platform("ngboost_predict_dist", [NGBoostModelBlobType, MatrixType, NGBoostPredictConfigType], NGBoostPredictResultType);
+export const ngboost_predict_dist = East.platform("ngboost_predict_dist", [NGBoostModelBlobType, MatrixType(FloatType), NGBoostPredictConfigType], NGBoostPredictResultType);
 // ============================================================================
 // Grouped Export
 // ============================================================================
@@ -125,10 +125,6 @@ export const ngboost_predict_dist = East.platform("ngboost_predict_dist", [NGBoo
  * Type definitions for NGBoost functions.
  */
 export const NGBoostTypes = {
-    /** Vector type (array of floats) */
-    VectorType,
-    /** Matrix type (2D array of floats) */
-    MatrixType,
     /** Distribution type for NGBoost */
     NGBoostDistributionType,
     /** NGBoost configuration type */
@@ -166,11 +162,68 @@ export const NGBoostTypes = {
  * ```
  */
 export const NGBoost = {
-    /** Train NGBoost regressor */
+    /**
+     * Train an NGBoost regression model with probabilistic output.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, VectorType, variant } from "@elaraai/east";
+     * import { NGBoost, NGBoostConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function([], NGBoost.Types.ModelBlobType, ($) => {
+     *     const X = $.let([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]);
+     *     const y = $.let(new Float64Array([1.0, 2.0, 3.0, 4.0]));
+     *     const config = $.let({
+     *         n_estimators: variant("some", 100n), learning_rate: variant("some", 0.01),
+     *         minibatch_frac: variant("none", null), col_sample: variant("none", null),
+     *         random_state: variant("some", 42n), distribution: variant("none", null),
+     *     }, NGBoostConfigType);
+     *     return $.return(NGBoost.trainRegressor(X, y, config));
+     * });
+     * ```
+     */
     trainRegressor: ngboost_train_regressor,
-    /** Make point predictions with regressor */
+    /**
+     * Make point predictions with a trained NGBoost regressor.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, VectorType } from "@elaraai/east";
+     * import { NGBoost } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [NGBoost.Types.ModelBlobType, MatrixType(FloatType)],
+     *     VectorType(FloatType),
+     *     ($, model, X) => {
+     *         return $.return(NGBoost.predict(model, X));
+     *     }
+     * );
+     * ```
+     */
     predict: ngboost_predict,
-    /** Get predictions with uncertainty */
+    /**
+     * Get predictions with uncertainty estimates (confidence intervals, std).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, variant } from "@elaraai/east";
+     * import { NGBoost, NGBoostPredictConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [NGBoost.Types.ModelBlobType, MatrixType(FloatType)],
+     *     NGBoost.Types.NGBoostPredictResultType,
+     *     ($, model, X) => {
+     *         const config = $.let({
+     *             confidence_level: variant("some", 0.95),
+     *         }, NGBoostPredictConfigType);
+     *         const result = $.let(NGBoost.predictDist(model, X, config));
+     *         // result.predictions => point predictions
+     *         // result.lower, result.upper => confidence interval
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
     predictDist: ngboost_predict_dist,
     /** Type definitions */
     Types: NGBoostTypes,

package/dist/src/ngboost/ngboost.js.map

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

package/dist/src/optimization/optimization.d.ts

@@ -0,0 +1,420 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Iterative coordinate descent optimization for discrete combinatorial problems.
+ *
+ * Provides element-wise optimization over vectors of discrete integer values.
+ * Each element is independently optimized by trying all candidate values
+ * while holding other elements fixed. Multi-start sampling improves
+ * exploration of the search space.
+ *
+ * Ported from the Julia IterativeDecisionAlgorithm (ArrayParameterSpace branch).
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, ArrayType, VectorType, IntegerType, BooleanType, FloatType, NullType, FunctionType } from "@elaraai/east";
+/** Parameter vector: Vector<Integer> */
+export declare const ParameterVectorType: VectorType<IntegerType>;
+/** Objective function: Vector<Integer> -> Float */
+export declare const IterativeObjectiveType: FunctionType<[VectorType<IntegerType>], FloatType>;
+/** Per-element candidate spaces: Array<Vector<Integer>> */
+export declare const ParameterSpacesType: ArrayType<VectorType<IntegerType>>;
+/**
+ * Initial value strategy for parameters.
+ *
+ * - `first`: Use the first candidate value from each space
+ * - `random`: Randomly select from each space
+ */
+export declare const InitialStrategyType: VariantType<{
+    readonly first: NullType;
+    readonly random: NullType;
+}>;
+/**
+ * Evaluation order for candidate values within each element's space.
+ *
+ * - `sequential`: Try candidates in the order they appear
+ * - `random`: Shuffle candidates before trying
+ */
+export declare const EvaluationOrderType: VariantType<{
+    readonly sequential: NullType;
+    readonly random: NullType;
+}>;
+/**
+ * Optimization mode.
+ *
+ * - `coordinate`: Standard coordinate descent — optimize each element independently (default)
+ * - `swap`: Swap-based moves — swap pairs of elements, preserving valid permutations
+ */
+export declare const ModeType: VariantType<{
+    readonly coordinate: NullType;
+    readonly swap: NullType;
+}>;
+/**
+ * Configuration for iterative optimization.
+ *
+ * All fields are optional with sensible defaults.
+ */
+export declare const IterativeConfigType: StructType<{
+    /** Maximum coordinate descent iterations per sample (default: 100) */
+    readonly iterations: OptionType<IntegerType>;
+    /** Number of independent restarts (default: 1) */
+    readonly samples: OptionType<IntegerType>;
+    /** How to initialize parameter values (default: first) */
+    readonly initial: OptionType<VariantType<{
+        readonly first: NullType;
+        readonly random: NullType;
+    }>>;
+    /** Order to evaluate candidates (default: sequential) */
+    readonly order: OptionType<VariantType<{
+        readonly sequential: NullType;
+        readonly random: NullType;
+    }>>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+    /** Optimization mode: coordinate (default) or swap for permutations */
+    readonly mode: OptionType<VariantType<{
+        readonly coordinate: NullType;
+        readonly swap: NullType;
+    }>>;
+}>;
+/**
+ * Result of iterative optimization.
+ */
+export declare const IterativeResultType: StructType<{
+    /** Best parameter values found */
+    readonly best_parameters: VectorType<IntegerType>;
+    /** Objective value at best parameters */
+    readonly best_objective: FloatType;
+    /** Total coordinate descent iterations across all samples */
+    readonly iterations: IntegerType;
+    /** Total number of objective evaluations */
+    readonly evaluations: IntegerType;
+    /** Whether optimization succeeded */
+    readonly success: BooleanType;
+}>;
+/**
+ * Iterative optimization over integer parameter vectors.
+ *
+ * Maximizes an objective function over a vector of discrete integer parameters.
+ * Each parameter position has its own set of candidate values (vector).
+ *
+ * Two modes are available:
+ * - **coordinate** (default): Coordinate descent — optimizes each element independently
+ *   by trying all candidate values while holding others fixed. Best for assignment problems
+ *   where each position can take any value independently.
+ * - **swap**: Swap-based moves — swaps pairs of elements, preserving valid permutations.
+ *   Use this for permutation problems (scheduling, ordering) where each value must appear
+ *   exactly once.
+ *
+ * @example Coordinate mode (assignment)
+ * ```ts
+ * const config = $.let({
+ *     iterations: variant('some', 10n),
+ *     samples: variant('some', 3n),
+ *     initial: variant('some', variant('random', null)),
+ *     order: variant('some', variant('sequential', null)),
+ *     random_state: variant('some', 42n),
+ *     mode: variant('none', null), // coordinate is the default
+ * });
+ * const result = $.let(Optimization.iterative(objective, spaces, config));
+ * ```
+ *
+ * @example Swap mode (permutation)
+ * ```ts
+ * const config = $.let({
+ *     iterations: variant('some', 50n),
+ *     samples: variant('some', 10n),
+ *     initial: variant('some', variant('random', null)),
+ *     order: variant('some', variant('random', null)),
+ *     random_state: variant('some', 42n),
+ *     mode: variant('some', variant('swap', null)),
+ * });
+ * const result = $.let(Optimization.iterative(objective, spaces, config));
+ * ```
+ */
+export declare const optimization_iterative: import("@elaraai/east").PlatformDefinition<[FunctionType<[VectorType<IntegerType>], FloatType>, ArrayType<VectorType<IntegerType>>, StructType<{
+    /** Maximum coordinate descent iterations per sample (default: 100) */
+    readonly iterations: OptionType<IntegerType>;
+    /** Number of independent restarts (default: 1) */
+    readonly samples: OptionType<IntegerType>;
+    /** How to initialize parameter values (default: first) */
+    readonly initial: OptionType<VariantType<{
+        readonly first: NullType;
+        readonly random: NullType;
+    }>>;
+    /** Order to evaluate candidates (default: sequential) */
+    readonly order: OptionType<VariantType<{
+        readonly sequential: NullType;
+        readonly random: NullType;
+    }>>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+    /** Optimization mode: coordinate (default) or swap for permutations */
+    readonly mode: OptionType<VariantType<{
+        readonly coordinate: NullType;
+        readonly swap: NullType;
+    }>>;
+}>], StructType<{
+    /** Best parameter values found */
+    readonly best_parameters: VectorType<IntegerType>;
+    /** Objective value at best parameters */
+    readonly best_objective: FloatType;
+    /** Total coordinate descent iterations across all samples */
+    readonly iterations: IntegerType;
+    /** Total number of objective evaluations */
+    readonly evaluations: IntegerType;
+    /** Whether optimization succeeded */
+    readonly success: BooleanType;
+}>>;
+/**
+ * Type definitions for iterative optimization.
+ */
+export declare const OptimizationTypes: {
+    /** Parameter vector type */
+    readonly ParameterVectorType: VectorType<IntegerType>;
+    /** Objective function type */
+    readonly ObjectiveType: FunctionType<[VectorType<IntegerType>], FloatType>;
+    /** Parameter spaces type */
+    readonly SpacesType: ArrayType<VectorType<IntegerType>>;
+    /** Initial value strategy variant */
+    readonly InitialStrategyType: VariantType<{
+        readonly first: NullType;
+        readonly random: NullType;
+    }>;
+    /** Evaluation order variant */
+    readonly EvaluationOrderType: VariantType<{
+        readonly sequential: NullType;
+        readonly random: NullType;
+    }>;
+    /** Optimization mode variant */
+    readonly ModeType: VariantType<{
+        readonly coordinate: NullType;
+        readonly swap: NullType;
+    }>;
+    /** Configuration type */
+    readonly ConfigType: StructType<{
+        /** Maximum coordinate descent iterations per sample (default: 100) */
+        readonly iterations: OptionType<IntegerType>;
+        /** Number of independent restarts (default: 1) */
+        readonly samples: OptionType<IntegerType>;
+        /** How to initialize parameter values (default: first) */
+        readonly initial: OptionType<VariantType<{
+            readonly first: NullType;
+            readonly random: NullType;
+        }>>;
+        /** Order to evaluate candidates (default: sequential) */
+        readonly order: OptionType<VariantType<{
+            readonly sequential: NullType;
+            readonly random: NullType;
+        }>>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+        /** Optimization mode: coordinate (default) or swap for permutations */
+        readonly mode: OptionType<VariantType<{
+            readonly coordinate: NullType;
+            readonly swap: NullType;
+        }>>;
+    }>;
+    /** Result type */
+    readonly ResultType: StructType<{
+        /** Best parameter values found */
+        readonly best_parameters: VectorType<IntegerType>;
+        /** Objective value at best parameters */
+        readonly best_objective: FloatType;
+        /** Total coordinate descent iterations across all samples */
+        readonly iterations: IntegerType;
+        /** Total number of objective evaluations */
+        readonly evaluations: IntegerType;
+        /** Whether optimization succeeded */
+        readonly success: BooleanType;
+    }>;
+};
+/**
+ * Iterative optimization for discrete combinatorial problems.
+ *
+ * Supports two modes:
+ * - **coordinate** (default): Element-wise coordinate descent. Best for
+ *   assignment problems where positions are independent.
+ * - **swap**: Pair-wise swap moves preserving permutations. Best for
+ *   scheduling/ordering where each value must appear exactly once.
+ *
+ * Use cases:
+ * - Task-worker assignment (coordinate mode)
+ * - Scheduling and ordering (swap mode)
+ * - Combinatorial selection problems
+ * - Any discrete optimization with per-element candidate sets
+ */
+export declare const Optimization: {
+    /**
+     * Iterative optimization over integer parameter vectors.
+     *
+     * `Optimization.iterative(objective, spaces, config)`
+     *
+     * @example Coordinate mode — task-worker assignment
+     * ```ts
+     * // 3 tasks, 2 workers. Maximize total skill match.
+     * const skill = $.let([[3.0, 1.0], [1.0, 3.0], [2.0, 2.0]]);
+     * const objective = East.function(
+     *     [VectorType(IntegerType)], FloatType,
+     *     ($, assignments) => {
+     *         const total = $.let(0.0);
+     *         $.for(East.Array.range(0n, East.value(3n)), ($, i) => {
+     *             $.assign(total, total.add(skill.get(i).get(assignments.get(i))));
+     *         });
+     *         return $.return(total);
+     *     }
+     * );
+     * const spaces = $.let([
+     *     new BigInt64Array([0n, 1n]),
+     *     new BigInt64Array([0n, 1n]),
+     *     new BigInt64Array([0n, 1n]),
+     * ]);
+     * const config = $.let({
+     *     iterations: variant('some', 10n),
+     *     samples: variant('some', 3n),
+     *     initial: variant('some', variant('random', null)),
+     *     order: variant('some', variant('sequential', null)),
+     *     random_state: variant('some', 42n),
+     *     mode: variant('none', null),
+     * });
+     * const result = $.let(Optimization.iterative(objective, spaces, config));
+     * // result.best_objective = 8.0 (task 0→worker 0, task 1→worker 1, task 2→either)
+     * ```
+     *
+     * @example Swap mode — scheduling permutation
+     * ```ts
+     * // 4 jobs: find execution order minimizing weighted completion time.
+     * const durations = $.let([10.0, 5.0, 20.0, 3.0]);
+     * const values = $.let([1.0, 8.0, 2.0, 10.0]);
+     * const objective = East.function(
+     *     [VectorType(IntegerType)], FloatType,
+     *     ($, perm) => {
+     *         const cum = $.let(0.0);
+     *         const total = $.let(0.0);
+     *         $.for(East.Array.range(0n, East.value(4n)), ($, i) => {
+     *             const idx = $.let(perm.get(i));
+     *             $.assign(cum, cum.add(durations.get(idx)));
+     *             $.assign(total, total.add(values.get(idx).multiply(cum)));
+     *         });
+     *         return $.return(total.negate());
+     *     }
+     * );
+     * const spaces = $.let([
+     *     new BigInt64Array([0n, 1n, 2n, 3n]),
+     *     new BigInt64Array([0n, 1n, 2n, 3n]),
+     *     new BigInt64Array([0n, 1n, 2n, 3n]),
+     *     new BigInt64Array([0n, 1n, 2n, 3n]),
+     * ]);
+     * const config = $.let({
+     *     iterations: variant('some', 50n),
+     *     samples: variant('some', 10n),
+     *     initial: variant('some', variant('random', null)),
+     *     order: variant('some', variant('random', null)),
+     *     random_state: variant('some', 42n),
+     *     mode: variant('some', variant('swap', null)),
+     * });
+     * const result = $.let(Optimization.iterative(objective, spaces, config));
+     * // result.best_objective = -188.0 (optimal WSPT order)
+     * ```
+     */
+    readonly iterative: import("@elaraai/east").PlatformDefinition<[FunctionType<[VectorType<IntegerType>], FloatType>, ArrayType<VectorType<IntegerType>>, StructType<{
+        /** Maximum coordinate descent iterations per sample (default: 100) */
+        readonly iterations: OptionType<IntegerType>;
+        /** Number of independent restarts (default: 1) */
+        readonly samples: OptionType<IntegerType>;
+        /** How to initialize parameter values (default: first) */
+        readonly initial: OptionType<VariantType<{
+            readonly first: NullType;
+            readonly random: NullType;
+        }>>;
+        /** Order to evaluate candidates (default: sequential) */
+        readonly order: OptionType<VariantType<{
+            readonly sequential: NullType;
+            readonly random: NullType;
+        }>>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+        /** Optimization mode: coordinate (default) or swap for permutations */
+        readonly mode: OptionType<VariantType<{
+            readonly coordinate: NullType;
+            readonly swap: NullType;
+        }>>;
+    }>], StructType<{
+        /** Best parameter values found */
+        readonly best_parameters: VectorType<IntegerType>;
+        /** Objective value at best parameters */
+        readonly best_objective: FloatType;
+        /** Total coordinate descent iterations across all samples */
+        readonly iterations: IntegerType;
+        /** Total number of objective evaluations */
+        readonly evaluations: IntegerType;
+        /** Whether optimization succeeded */
+        readonly success: BooleanType;
+    }>>;
+    /**
+     * Type definitions for optimization functions.
+     */
+    readonly Types: {
+        /** Parameter vector type */
+        readonly ParameterVectorType: VectorType<IntegerType>;
+        /** Objective function type */
+        readonly ObjectiveType: FunctionType<[VectorType<IntegerType>], FloatType>;
+        /** Parameter spaces type */
+        readonly SpacesType: ArrayType<VectorType<IntegerType>>;
+        /** Initial value strategy variant */
+        readonly InitialStrategyType: VariantType<{
+            readonly first: NullType;
+            readonly random: NullType;
+        }>;
+        /** Evaluation order variant */
+        readonly EvaluationOrderType: VariantType<{
+            readonly sequential: NullType;
+            readonly random: NullType;
+        }>;
+        /** Optimization mode variant */
+        readonly ModeType: VariantType<{
+            readonly coordinate: NullType;
+            readonly swap: NullType;
+        }>;
+        /** Configuration type */
+        readonly ConfigType: StructType<{
+            /** Maximum coordinate descent iterations per sample (default: 100) */
+            readonly iterations: OptionType<IntegerType>;
+            /** Number of independent restarts (default: 1) */
+            readonly samples: OptionType<IntegerType>;
+            /** How to initialize parameter values (default: first) */
+            readonly initial: OptionType<VariantType<{
+                readonly first: NullType;
+                readonly random: NullType;
+            }>>;
+            /** Order to evaluate candidates (default: sequential) */
+            readonly order: OptionType<VariantType<{
+                readonly sequential: NullType;
+                readonly random: NullType;
+            }>>;
+            /** Random seed for reproducibility */
+            readonly random_state: OptionType<IntegerType>;
+            /** Optimization mode: coordinate (default) or swap for permutations */
+            readonly mode: OptionType<VariantType<{
+                readonly coordinate: NullType;
+                readonly swap: NullType;
+            }>>;
+        }>;
+        /** Result type */
+        readonly ResultType: StructType<{
+            /** Best parameter values found */
+            readonly best_parameters: VectorType<IntegerType>;
+            /** Objective value at best parameters */
+            readonly best_objective: FloatType;
+            /** Total coordinate descent iterations across all samples */
+            readonly iterations: IntegerType;
+            /** Total number of objective evaluations */
+            readonly evaluations: IntegerType;
+            /** Whether optimization succeeded */
+            readonly success: BooleanType;
+        }>;
+    };
+};
+//# sourceMappingURL=optimization.d.ts.map

package/dist/src/optimization/optimization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimization.d.ts","sourceRoot":"","sources":["../../../src/optimization/optimization.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAEH,UAAU,EACV,WAAW,EACX,UAAU,EACV,SAAS,EACT,UAAU,EACV,WAAW,EACX,WAAW,EACX,SAAS,EACT,QAAQ,EACR,YAAY,EACf,MAAM,eAAe,CAAC;AAMvB,wCAAwC;AACxC,eAAO,MAAM,mBAAmB,yBAA0B,CAAC;AAE3D,mDAAmD;AACnD,eAAO,MAAM,sBAAsB,oDAAiD,CAAC;AAErF,2DAA2D;AAC3D,eAAO,MAAM,mBAAmB,oCAAiC,CAAC;AAElE;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;EAG9B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;EAG9B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;;;EAGnB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;IAC5B,sEAAsE;;IAEtE,kDAAkD;;IAElD,0DAA0D;;;;;IAE1D,yDAAyD;;;;;IAEzD,sCAAsC;;IAEtC,uEAAuE;;;;;EAEzE,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;IAC5B,kCAAkC;;IAElC,yCAAyC;;IAEzC,6DAA6D;;IAE7D,4CAA4C;;IAE5C,qCAAqC;;EAEvC,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,sBAAsB;IA1E/B,sEAAsE;;IAEtE,kDAAkD;;IAElD,0DAA0D;;;;;IAE1D,yDAAyD;;;;;IAEzD,sCAAsC;;IAEtC,uEAAuE;;;;;;IAQvE,kCAAkC;;IAElC,yCAAyC;;IAEzC,6DAA6D;;IAE7D,4CAA4C;;IAE5C,qCAAqC;;GAwDxC,CAAC;AAMF;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC1B,4BAA4B;;IAE5B,8BAA8B;;IAE9B,4BAA4B;;IAE5B,qCAAqC;;;;;IAErC,+BAA+B;;;;;IAE/B,gCAAgC;;;;;IAEhC,yBAAyB;;QAxGzB,sEAAsE;;QAEtE,kDAAkD;;QAElD,0DAA0D;;;;;QAE1D,yDAAyD;;;;;QAEzD,sCAAsC;;QAEtC,uEAAuE;;;;;;IAgGvE,kBAAkB;;QAxFlB,kCAAkC;;QAElC,yCAAyC;;QAEzC,6DAA6D;;QAE7D,4CAA4C;;QAE5C,qCAAqC;;;CAkF/B,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY;IACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuEG;;QArMH,sEAAsE;;QAEtE,kDAAkD;;QAElD,0DAA0D;;;;;QAE1D,yDAAyD;;;;;QAEzD,sCAAsC;;QAEtC,uEAAuE;;;;;;QAQvE,kCAAkC;;QAElC,yCAAyC;;QAEzC,6DAA6D;;QAE7D,4CAA4C;;QAE5C,qCAAqC;;;IA8KrC;;OAEG;;QA9GH,4BAA4B;;QAE5B,8BAA8B;;QAE9B,4BAA4B;;QAE5B,qCAAqC;;;;;QAErC,+BAA+B;;;;;QAE/B,gCAAgC;;;;;QAEhC,yBAAyB;;YAxGzB,sEAAsE;;YAEtE,kDAAkD;;YAElD,0DAA0D;;;;;YAE1D,yDAAyD;;;;;YAEzD,sCAAsC;;YAEtC,uEAAuE;;;;;;QAgGvE,kBAAkB;;YAxFlB,kCAAkC;;YAElC,yCAAyC;;YAEzC,6DAA6D;;YAE7D,4CAA4C;;YAE5C,qCAAqC;;;;CAkL/B,CAAC"}