@higher.archi/boe 1.0.0

package/dist/engines/fuzzy/fuzzy.types.d.ts

@@ -0,0 +1,213 @@
+/**
+ * Fuzzy Engine Types
+ *
+ * Complete fuzzy logic types for membership functions, defuzzification,
+ * and fuzzy inference. Self-contained within the fuzzy engine.
+ */
+import { BindingContext } from '../../core';
+/**
+ * Membership function shapes
+ * These define how membership degree (0-1) is calculated from a crisp value
+ */
+export type MembershipShape = 'triangle' | 'trapezoid' | 'gaussian' | 'shoulder' | 'block';
+/**
+ * Semantic position within domain (compiles to numeric center)
+ */
+export type PositionSemantic = 'very-low' | 'low' | 'medium' | 'high' | 'very-high';
+/**
+ * Semantic width/spread (compiles to numeric spread as % of domain)
+ */
+export type WidthSemantic = 'tight' | 'narrow' | 'medium' | 'wide' | 'very-wide';
+/**
+ * Edge behavior for shoulder/block shapes
+ */
+export type EdgeSemantic = 'open-left' | 'open-right' | 'closed';
+/**
+ * Semantic fuzzy term - uses intuitive descriptors
+ * Compiles to explicit numeric parameters at compile time
+ */
+export type SemanticFuzzyTerm = {
+    name: string;
+    shape: MembershipShape;
+    position: PositionSemantic;
+    width: WidthSemantic;
+    edge?: EdgeSemantic;
+};
+/**
+ * Explicit fuzzy term - direct numeric parameters
+ * For advanced users who need precise control
+ */
+export type ExplicitFuzzyTerm = {
+    name: string;
+    shape: MembershipShape;
+    params: number[];
+};
+/**
+ * Union of term definition types
+ */
+export type FuzzyTerm = SemanticFuzzyTerm | ExplicitFuzzyTerm;
+/**
+ * Type guard for semantic terms
+ */
+export declare function isSemanticTerm(term: FuzzyTerm): term is SemanticFuzzyTerm;
+/**
+ * Type guard for explicit terms
+ */
+export declare function isExplicitTerm(term: FuzzyTerm): term is ExplicitFuzzyTerm;
+/**
+ * A fuzzy linguistic variable with its domain and terms
+ */
+export type FuzzyVariable = {
+    name: string;
+    domain: [number, number];
+    terms: FuzzyTerm[];
+};
+/**
+ * Compiled membership function - all terms resolved to numeric params
+ */
+export type CompiledMembershipFunction = {
+    shape: MembershipShape;
+    params: number[];
+};
+/**
+ * Compiled fuzzy term
+ */
+export type CompiledFuzzyTerm = {
+    name: string;
+    membership: CompiledMembershipFunction;
+};
+/**
+ * Compiled fuzzy variable
+ */
+export type CompiledFuzzyVariable = {
+    name: string;
+    domain: [number, number];
+    terms: CompiledFuzzyTerm[];
+    termIndex: Map<string, CompiledFuzzyTerm>;
+};
+/**
+ * Aggregation methods - combine multiple rule activations for same output
+ */
+export type AggregationMethod = 'max' | 'sum' | 'probor' | 'bound' | 'min';
+/**
+ * Defuzzification methods - convert fuzzy output to crisp value
+ */
+export type DefuzzifyMethod = 'centroid' | 'bisector' | 'mom' | 'som' | 'lom' | 'wtaver';
+/**
+ * Transform methods - post-process the crisp output
+ */
+export type TransformMethod = 'clamp' | 'round' | 'deadband' | 'scale' | 'quantize';
+/**
+ * Any defuzzification pipeline stage
+ */
+export type DefuzzifyStage = AggregationMethod | DefuzzifyMethod | TransformMethod;
+/**
+ * Named presets that expand to full pipelines
+ */
+export type DefuzzifyPreset = 'balanced' | 'smooth' | 'decisive' | 'cautious' | 'aggressive' | 'discrete' | 'stable';
+/**
+ * Defuzzification pipeline configuration
+ */
+export type DefuzzifyConfig = DefuzzifyPreset | DefuzzifyStage[];
+/**
+ * Simple output - just the term reference
+ */
+export type FuzzyOutputSimple = string;
+/**
+ * Explicit output with optional degree override
+ */
+export type FuzzyOutputExplicit = {
+    output: string;
+    degree?: number;
+};
+/**
+ * Fuzzy rule output
+ */
+export type FuzzyOutput = FuzzyOutputSimple | FuzzyOutputExplicit;
+/**
+ * Compiled fuzzy action
+ */
+export type CompiledFuzzyAction = {
+    mode: 'fuzzy';
+    output: {
+        variable: string;
+        term: string;
+    };
+    degree?: number;
+};
+/**
+ * Coverage auto-adjustment options
+ */
+export type CoverageOptions = {
+    /** Target minimum coverage (default 0.3) */
+    targetMinCoverage?: number;
+    /** Maximum width multiplier to apply (default 2.0) */
+    maxWidthMultiplier?: number;
+    /** Resolution for coverage analysis (default 100) */
+    resolution?: number;
+};
+/**
+ * Fuzzy strategy configuration
+ */
+export type FuzzyConfig = {
+    mode: 'fuzzy';
+    threshold?: number;
+    defuzzify?: DefuzzifyConfig;
+    coverage?: CoverageOptions | boolean;
+};
+/**
+ * Runtime options for fuzzy execution
+ */
+export type FuzzyOptions = {
+    onFire?: (ruleId: string, context: BindingContext, degree: number) => void;
+};
+/**
+ * Membership values for a single variable
+ */
+export type VariableMemberships = Record<string, number>;
+/**
+ * All input memberships calculated during fuzzification
+ */
+export type FuzzificationResult = Record<string, VariableMemberships>;
+/**
+ * Rule activation during inference
+ */
+export type FuzzyActivation = {
+    ruleId: string;
+    outputVariable: string;
+    outputTerm: string;
+    degree: number;
+};
+/**
+ * Aggregated outputs before defuzzification
+ */
+export type AggregatedOutputs = Record<string, VariableMemberships>;
+/**
+ * Final crisp output values
+ */
+export type CrispOutputs = Record<string, number>;
+/**
+ * Full fuzzy execution result
+ */
+export type FuzzyResult = {
+    memberships: FuzzificationResult;
+    activations: FuzzyActivation[];
+    aggregated: AggregatedOutputs;
+    fired: string[];
+    iterations: 1;
+    outputs: CrispOutputs;
+    executionTimeMs: number;
+};
+/**
+ * Expand a defuzzify preset to its pipeline stages
+ */
+export declare function expandDefuzzifyPreset(preset: DefuzzifyPreset): DefuzzifyStage[];
+/**
+ * Semantic position to numeric value (0-1 within domain)
+ */
+export declare const POSITION_VALUES: Record<PositionSemantic, number>;
+/**
+ * Semantic width to numeric spread (as fraction of domain range)
+ */
+export declare const WIDTH_VALUES: Record<WidthSemantic, number>;
+//# sourceMappingURL=fuzzy.types.d.ts.map

package/dist/engines/fuzzy/fuzzy.types.d.ts.map

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

package/dist/engines/fuzzy/fuzzy.types.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Fuzzy Engine Types
+ *
+ * Complete fuzzy logic types for membership functions, defuzzification,
+ * and fuzzy inference. Self-contained within the fuzzy engine.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WIDTH_VALUES = exports.POSITION_VALUES = void 0;
+exports.isSemanticTerm = isSemanticTerm;
+exports.isExplicitTerm = isExplicitTerm;
+exports.expandDefuzzifyPreset = expandDefuzzifyPreset;
+/**
+ * Type guard for semantic terms
+ */
+function isSemanticTerm(term) {
+    return 'position' in term && 'width' in term;
+}
+/**
+ * Type guard for explicit terms
+ */
+function isExplicitTerm(term) {
+    return 'params' in term;
+}
+// ========================================
+// Preset Expansions
+// ========================================
+/**
+ * Expand a defuzzify preset to its pipeline stages
+ */
+function expandDefuzzifyPreset(preset) {
+    switch (preset) {
+        case 'balanced':
+            return ['max', 'centroid', 'clamp'];
+        case 'smooth':
+            return ['probor', 'centroid', 'clamp'];
+        case 'decisive':
+            return ['max', 'mom'];
+        case 'cautious':
+            return ['max', 'som', 'clamp'];
+        case 'aggressive':
+            return ['max', 'lom', 'clamp'];
+        case 'discrete':
+            return ['max', 'centroid', 'clamp', 'round'];
+        case 'stable':
+            return ['max', 'centroid', 'deadband', 'clamp'];
+        default:
+            throw new Error(`Unknown defuzzify preset: ${preset}`);
+    }
+}
+/**
+ * Semantic position to numeric value (0-1 within domain)
+ */
+exports.POSITION_VALUES = {
+    'very-low': 0.10,
+    'low': 0.25,
+    'medium': 0.50,
+    'high': 0.75,
+    'very-high': 0.90
+};
+/**
+ * Semantic width to numeric spread (as fraction of domain range)
+ */
+exports.WIDTH_VALUES = {
+    'tight': 0.02,
+    'narrow': 0.05,
+    'medium': 0.10,
+    'wide': 0.20,
+    'very-wide': 0.35
+};
+//# sourceMappingURL=fuzzy.types.js.map

package/dist/engines/fuzzy/fuzzy.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzy.types.js","sourceRoot":"","sources":["../../../src/engines/fuzzy/fuzzy.types.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AA+DH,wCAEC;AAKD,wCAEC;AA8OD,sDAmBC;AA7QD;;GAEG;AACH,SAAgB,cAAc,CAAC,IAAe;IAC5C,OAAO,UAAU,IAAI,IAAI,IAAI,OAAO,IAAI,IAAI,CAAC;AAC/C,CAAC;AAED;;GAEG;AACH,SAAgB,cAAc,CAAC,IAAe;IAC5C,OAAO,QAAQ,IAAI,IAAI,CAAC;AAC1B,CAAC;AAuOD,2CAA2C;AAC3C,oBAAoB;AACpB,2CAA2C;AAE3C;;GAEG;AACH,SAAgB,qBAAqB,CAAC,MAAuB;IAC3D,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,UAAU;YACb,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;QACtC,KAAK,QAAQ;YACX,OAAO,CAAC,QAAQ,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;QACzC,KAAK,UAAU;YACb,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACxB,KAAK,UAAU;YACb,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QACjC,KAAK,YAAY;YACf,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QACjC,KAAK,UAAU;YACb,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QAC/C,KAAK,QAAQ;YACX,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;QAClD;YACE,MAAM,IAAI,KAAK,CAAC,6BAA6B,MAAM,EAAE,CAAC,CAAC;IAC3D,CAAC;AACH,CAAC;AAED;;GAEG;AACU,QAAA,eAAe,GAAqC;IAC/D,UAAU,EAAE,IAAI;IAChB,KAAK,EAAE,IAAI;IACX,QAAQ,EAAE,IAAI;IACd,MAAM,EAAE,IAAI;IACZ,WAAW,EAAE,IAAI;CAClB,CAAC;AAEF;;GAEG;AACU,QAAA,YAAY,GAAkC;IACzD,OAAO,EAAE,IAAI;IACb,QAAQ,EAAE,IAAI;IACd,QAAQ,EAAE,IAAI;IACd,MAAM,EAAE,IAAI;IACZ,WAAW,EAAE,IAAI;CAClB,CAAC"}

package/dist/engines/fuzzy/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Fuzzy Engine
+ *
+ * Provides fuzzy logic rule execution with:
+ * - Linguistic variables and membership functions
+ * - Fuzzy conditions (is/isNot operators)
+ * - Defuzzification pipelines
+ * - Coverage auto-adjustment
+ */
+export * from './types';
+export { compileFuzzyRule, compileFuzzyRuleSet, CompiledFuzzyRuleSet, CompiledFuzzyRule } from './compiler';
+export { FuzzyStrategy, fuzzyStrategy, evaluateFuzzyIs, evaluateFuzzyIsNot, FuzzyEvaluationContext } from './strategy';
+export * from './membership';
+export * from './defuzzify';
+export { FuzzyEngine } from './engine';
+//# sourceMappingURL=index.d.ts.map

package/dist/engines/fuzzy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engines/fuzzy/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,cAAc,SAAS,CAAC;AAGxB,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,aAAa,EACb,aAAa,EACb,eAAe,EACf,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAGpB,cAAc,cAAc,CAAC;AAG7B,cAAc,aAAa,CAAC;AAG5B,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC"}

package/dist/engines/fuzzy/index.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Fuzzy Engine
+ *
+ * Provides fuzzy logic rule execution with:
+ * - Linguistic variables and membership functions
+ * - Fuzzy conditions (is/isNot operators)
+ * - Defuzzification pipelines
+ * - Coverage auto-adjustment
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FuzzyEngine = exports.evaluateFuzzyIsNot = exports.evaluateFuzzyIs = exports.fuzzyStrategy = exports.FuzzyStrategy = exports.compileFuzzyRuleSet = exports.compileFuzzyRule = void 0;
+// Types
+__exportStar(require("./types"), exports);
+// Compiler
+var compiler_1 = require("./compiler");
+Object.defineProperty(exports, "compileFuzzyRule", { enumerable: true, get: function () { return compiler_1.compileFuzzyRule; } });
+Object.defineProperty(exports, "compileFuzzyRuleSet", { enumerable: true, get: function () { return compiler_1.compileFuzzyRuleSet; } });
+// Strategy
+var strategy_1 = require("./strategy");
+Object.defineProperty(exports, "FuzzyStrategy", { enumerable: true, get: function () { return strategy_1.FuzzyStrategy; } });
+Object.defineProperty(exports, "fuzzyStrategy", { enumerable: true, get: function () { return strategy_1.fuzzyStrategy; } });
+Object.defineProperty(exports, "evaluateFuzzyIs", { enumerable: true, get: function () { return strategy_1.evaluateFuzzyIs; } });
+Object.defineProperty(exports, "evaluateFuzzyIsNot", { enumerable: true, get: function () { return strategy_1.evaluateFuzzyIsNot; } });
+// Membership functions
+__exportStar(require("./membership"), exports);
+// Defuzzification
+__exportStar(require("./defuzzify"), exports);
+// Engine
+var engine_1 = require("./engine");
+Object.defineProperty(exports, "FuzzyEngine", { enumerable: true, get: function () { return engine_1.FuzzyEngine; } });
+//# sourceMappingURL=index.js.map

package/dist/engines/fuzzy/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/engines/fuzzy/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;;;;;;;;;;;;;;;AAEH,QAAQ;AACR,0CAAwB;AAExB,WAAW;AACX,uCAKoB;AAJlB,4GAAA,gBAAgB,OAAA;AAChB,+GAAA,mBAAmB,OAAA;AAKrB,WAAW;AACX,uCAMoB;AALlB,yGAAA,aAAa,OAAA;AACb,yGAAA,aAAa,OAAA;AACb,2GAAA,eAAe,OAAA;AACf,8GAAA,kBAAkB,OAAA;AAIpB,uBAAuB;AACvB,+CAA6B;AAE7B,kBAAkB;AAClB,8CAA4B;AAE5B,SAAS;AACT,mCAAuC;AAA9B,qGAAA,WAAW,OAAA"}

package/dist/engines/fuzzy/membership.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Fuzzy Engine Membership Functions
+ *
+ * Re-exports membership functions from local fuzzy.membership module.
+ */
+export { compileFuzzyVariable, parseTermRef, fuzzifyValue, getMembershipDegree, evaluateMembership, analyzeCoverage, autoAdjustCoverage, AutoAdjustOptions, CoverageAnalysis } from './fuzzy.membership';
+//# sourceMappingURL=membership.d.ts.map

package/dist/engines/fuzzy/membership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"membership.d.ts","sourceRoot":"","sources":["../../../src/engines/fuzzy/membership.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAEL,oBAAoB,EACpB,YAAY,EACZ,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,EAGlB,eAAe,EACf,kBAAkB,EAGlB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,oBAAoB,CAAC"}

package/dist/engines/fuzzy/membership.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Fuzzy Engine Membership Functions
+ *
+ * Re-exports membership functions from local fuzzy.membership module.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoAdjustCoverage = exports.analyzeCoverage = exports.evaluateMembership = exports.getMembershipDegree = exports.fuzzifyValue = exports.parseTermRef = exports.compileFuzzyVariable = void 0;
+var fuzzy_membership_1 = require("./fuzzy.membership");
+// Core functions
+Object.defineProperty(exports, "compileFuzzyVariable", { enumerable: true, get: function () { return fuzzy_membership_1.compileFuzzyVariable; } });
+Object.defineProperty(exports, "parseTermRef", { enumerable: true, get: function () { return fuzzy_membership_1.parseTermRef; } });
+Object.defineProperty(exports, "fuzzifyValue", { enumerable: true, get: function () { return fuzzy_membership_1.fuzzifyValue; } });
+Object.defineProperty(exports, "getMembershipDegree", { enumerable: true, get: function () { return fuzzy_membership_1.getMembershipDegree; } });
+Object.defineProperty(exports, "evaluateMembership", { enumerable: true, get: function () { return fuzzy_membership_1.evaluateMembership; } });
+// Coverage analysis and adjustment
+Object.defineProperty(exports, "analyzeCoverage", { enumerable: true, get: function () { return fuzzy_membership_1.analyzeCoverage; } });
+Object.defineProperty(exports, "autoAdjustCoverage", { enumerable: true, get: function () { return fuzzy_membership_1.autoAdjustCoverage; } });
+//# sourceMappingURL=membership.js.map

package/dist/engines/fuzzy/membership.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"membership.js","sourceRoot":"","sources":["../../../src/engines/fuzzy/membership.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,uDAe4B;AAd1B,iBAAiB;AACjB,wHAAA,oBAAoB,OAAA;AACpB,gHAAA,YAAY,OAAA;AACZ,gHAAA,YAAY,OAAA;AACZ,uHAAA,mBAAmB,OAAA;AACnB,sHAAA,kBAAkB,OAAA;AAElB,mCAAmC;AACnC,mHAAA,eAAe,OAAA;AACf,sHAAA,kBAAkB,OAAA"}

package/dist/engines/fuzzy/strategy.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Fuzzy Engine Strategy
+ *
+ * Fuzzy inference engine implementation.
+ * Self-contained within the fuzzy engine.
+ */
+import { IWorkingMemory, BindingContext } from '../../core';
+import { CompiledFuzzyRuleSet } from './compiler';
+import { FuzzyOptions, FuzzyResult, CompiledFuzzyVariable } from './types';
+/**
+ * Context for fuzzy evaluation including compiled variables
+ */
+export type FuzzyEvaluationContext = {
+    bindings: BindingContext;
+    variables: Map<string, CompiledFuzzyVariable>;
+    threshold: number;
+};
+/**
+ * Evaluate a fuzzy 'is' condition
+ * Returns the membership degree (0-1) rather than boolean
+ */
+export declare function evaluateFuzzyIs(value: number, termRef: string, ctx: FuzzyEvaluationContext): number;
+/**
+ * Evaluate a fuzzy 'isNot' condition
+ * Returns 1 - membership degree
+ */
+export declare function evaluateFuzzyIsNot(value: number, termRef: string, ctx: FuzzyEvaluationContext): number;
+export declare class FuzzyStrategy {
+    run(ruleSet: CompiledFuzzyRuleSet, wm: IWorkingMemory, options?: FuzzyOptions): FuzzyResult;
+    /**
+     * Extract aggregation method from defuzzify config
+     */
+    private getAggregationMethod;
+    /**
+     * Evaluate a rule's conditions to determine activation degree
+     *
+     * For fuzzy rules, the 'where' clause can contain:
+     * - ['is', '$var.path', 'variable.term'] - returns membership degree
+     * - ['isNot', '$var.path', 'variable.term'] - returns 1 - membership
+     * - ['and', [...], [...]] - min of degrees
+     * - ['or', [...], [...]] - max of degrees
+     * - Standard boolean operators - return 1 or 0
+     */
+    private evaluateRuleDegree;
+    /**
+     * Recursively evaluate a fuzzy condition tree
+     */
+    private evaluateFuzzyCondition;
+    /**
+     * Evaluate a standard boolean condition (non-fuzzy)
+     */
+    private evaluateBooleanCondition;
+    /**
+     * Resolve a value from an operand
+     */
+    private resolveValue;
+}
+export declare const fuzzyStrategy: FuzzyStrategy;
+//# sourceMappingURL=strategy.d.ts.map

package/dist/engines/fuzzy/strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../src/engines/fuzzy/strategy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,cAAc,EAAE,cAAc,EAAsC,MAAM,YAAY,CAAC;AAChG,OAAO,EAAE,oBAAoB,EAAqB,MAAM,YAAY,CAAC;AACrE,OAAO,EACL,YAAY,EACZ,WAAW,EAEX,qBAAqB,EAStB,MAAM,SAAS,CAAC;AAYjB;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,EAAE,cAAc,CAAC;IACzB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;IAC9C,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,sBAAsB,GAC1B,MAAM,CASR;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,sBAAsB,GAC1B,MAAM,CAER;AAMD,qBAAa,aAAa;IACxB,GAAG,CACD,OAAO,EAAE,oBAAoB,EAC7B,EAAE,EAAE,cAAc,EAClB,OAAO,GAAE,YAAiB,GACzB,WAAW;IAmHd;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAgB5B;;;;;;;;;OASG;IACH,OAAO,CAAC,kBAAkB;IAiB1B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAuF9B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAIhC;;OAEG;IACH,OAAO,CAAC,YAAY;CAyBrB;AAGD,eAAO,MAAM,aAAa,eAAsB,CAAC"}