@genome-spy/core 0.67.0 → 0.69.0

package/dist/src/paramRuntime/viewParamRuntime.js

@@ -0,0 +1,443 @@
+import { isString } from "vega-util";
+import ParamRuntime from "./paramRuntime.js";
+import {
+    getDefaultParamValue,
+    isSelectionParameter,
+    validateParameterName,
+} from "./paramUtils.js";
+
+export {
+    activateExprRefProps,
+    getDefaultParamValue,
+    isExprRef,
+    isSelectionParameter,
+    isVariableParameter,
+    makeConstantExprRef,
+    validateParameterName,
+    withoutExprRef,
+} from "./paramUtils.js";
+
+/**
+ * A class that manages parameters and expressions.
+ * Supports nesting and scoped parameters through a shared runtime graph.
+ * The architecture follows signal-graph ideas (explicit dependencies, batched
+ * propagation, deterministic scheduling) while keeping GenomeSpy-specific
+ * parameter and expression semantics.
+ *
+ * @typedef {import("../utils/expression.js").ExpressionFunction & { subscribe: (listener: () => void) => () => void, invalidate: () => void, identifier: () => string}} ExprRefFunction
+ */
+export default class ViewParamRuntime {
+    /**
+     * @typedef {import("../spec/parameter.js").Parameter} Parameter
+     * @typedef {(value: any) => void} ParameterSetter
+     *
+     * @typedef {object} WatchExpressionOptions
+     * @prop {boolean} [scopeOwned=true]
+     *      Whether the subscription lifecycle is owned by this runtime scope.
+     *      When true, the listener is unsubscribed automatically during
+     *      `dispose()` via scope disposal. Set to false when another owner
+     *      (for example a `View` disposer registry) controls teardown.
+     * @prop {(disposer: () => void) => void} [registerDisposer]
+     *      Optional external disposer registration hook. When provided, the
+     *      unsubscribe callback is passed to this hook in addition to any
+     *      scope-owned registration.
+     */
+
+    /** @type {ParamRuntime} */
+    #runtime;
+
+    /** @type {string} */
+    #scopeId;
+
+    /** @type {Map<string, (value: any) => void>} */
+    #allocatedSetters = new Map();
+
+    /** @type {Map<string, import("./types.js").ParamRef<any>>} */
+    #localRefs = new Map();
+
+    /** @type {Map<string, Parameter>} */
+    #paramConfigs = new Map();
+
+    /** @type {() => ViewParamRuntime} */
+    #parentFinder;
+
+    #disposed = false;
+
+    /**
+     * @param {() => ViewParamRuntime} [parentFinder]
+     *      An optional function that returns the parent runtime.
+     *      N.B. The function must always return the same runtime for the same parent,
+     *      i.e., the changing the structure of the hierarchy is NOT supported.
+     */
+    constructor(parentFinder) {
+        this.#parentFinder = parentFinder ?? (() => undefined);
+
+        const parent = this.#parentFinder();
+        if (parent) {
+            this.#runtime = parent.#runtime;
+            this.#scopeId = this.#runtime.createScope(parent.#scopeId);
+        } else {
+            this.#runtime = new ParamRuntime();
+            this.#scopeId = this.#runtime.createScope();
+        }
+    }
+
+    /**
+     * Registers a parameter definition into this runtime scope.
+     *
+     * Returns a writable setter for writable parameters (`value`, `select`,
+     * `push: "outer"`). For derived (`expr`) parameters, the returned setter
+     * throws.
+     *
+     * A parameter name can be registered only once per runtime scope.
+     *
+     * @param {Parameter} param
+     * @returns {ParameterSetter}
+     */
+    registerParam(param) {
+        const name = param.name;
+        validateParameterName(name);
+
+        if (this.#paramConfigs.has(name)) {
+            throw new Error(
+                'Parameter "' + name + '" already registered in this scope.'
+            );
+        }
+
+        if ("value" in param && "expr" in param) {
+            throw new Error(
+                `The parameter "${name}" must not have both value and expr properties!`
+            );
+        }
+
+        /** @type {ParameterSetter} */
+        let setter;
+        let defaultValue;
+
+        if (param.push == "outer") {
+            const outerRuntime = this.findRuntimeForParam(name);
+            if (!outerRuntime) {
+                throw new Error(
+                    `Parameter "${name}" not found in outer scope!`
+                );
+            }
+
+            const outerProps = outerRuntime.paramConfigs.get(name);
+            if (!outerProps) {
+                throw new Error(
+                    `Outer parameter "${name}" exists as a value but has no registered config.`
+                );
+            }
+            if ("expr" in outerProps || "select" in outerProps) {
+                throw new Error(
+                    `The outer parameter "${name}" must not have expr or select properties!`
+                );
+            }
+            setter = (
+                /** @type {any} */
+                value
+            ) => {
+                outerRuntime.setValue(name, value);
+            };
+            // The following will become a bit fragile if the view hierarchy is going to
+            // support mutation (i.e. adding/removing children) in future.
+            this.#allocatedSetters.set(name, setter);
+        } else if ("value" in param) {
+            defaultValue = getDefaultParamValue(param, this);
+            setter = this.#registerBaseSetter(name, defaultValue);
+        } else if ("expr" in param) {
+            const ref = this.#runtime.registerDerived(
+                this.#scopeId,
+                name,
+                param.expr
+            );
+            this.#localRefs.set(name, ref);
+            setter = () => {
+                throw new Error('Cannot set derived parameter "' + name + '".');
+            };
+        } else {
+            defaultValue = getDefaultParamValue(param, this);
+            setter = this.#registerBaseSetter(name, defaultValue);
+        }
+
+        if ("select" in param) {
+            defaultValue ??= getDefaultParamValue(param, this);
+            if (!this.#allocatedSetters.has(name)) {
+                const ref = this.#runtime.registerSelection(
+                    this.#scopeId,
+                    name,
+                    defaultValue
+                );
+                this.#localRefs.set(name, ref);
+                this.#allocatedSetters.set(name, (value) => {
+                    ref.set(value);
+                    this.#runtime.flushNow();
+                });
+                setter = this.#allocatedSetters.get(name);
+            }
+            // Set initial value so that production rules in shaders can be generated, etc.
+            setter(defaultValue);
+        }
+
+        this.#paramConfigs.set(name, param);
+
+        return setter;
+    }
+
+    /**
+     *
+     * @param {string} paramName
+     * @param {T} initialValue
+     * @param {boolean} [passive] If true, the setter will not notify listeners when the value changes.
+     * @returns {(value: T) => void}
+     * @template T
+     */
+    allocateSetter(paramName, initialValue, passive = false) {
+        validateParameterName(paramName);
+
+        if (this.#allocatedSetters.has(paramName)) {
+            throw new Error(
+                "Setter already allocated for parameter: " + paramName
+            );
+        }
+
+        const ref = this.#runtime.registerBase(
+            this.#scopeId,
+            paramName,
+            initialValue,
+            {
+                notify: !passive,
+            }
+        );
+        this.#localRefs.set(paramName, ref);
+        const setter = (
+            /** @type {T} */
+            value
+        ) => {
+            ref.set(value);
+            this.#runtime.flushNow();
+        };
+
+        this.#allocatedSetters.set(paramName, setter);
+
+        return setter;
+    }
+
+    /**
+     * Sets a writable parameter value in this runtime scope.
+     *
+     * Only parameters with locally registered writable setters are supported.
+     * This method does not resolve through ancestors.
+     *
+     * @param {string} paramName
+     * @param {any} value
+     */
+    setValue(paramName, value) {
+        validateParameterName(paramName);
+        const setter = this.#allocatedSetters.get(paramName);
+        if (!setter) {
+            throw new Error(
+                "Writable parameter not found in this scope: " + paramName
+            );
+        }
+        setter(value);
+    }
+
+    /**
+     * Get the value of a parameter from this runtime.
+     * @param {string} paramName
+     */
+    getValue(paramName) {
+        return this.#localRefs.get(paramName)?.get();
+    }
+
+    /**
+     * Subscribe to changes of a parameter's value. The listener is called only
+     * when the stored value changes. For expression parameters, the listener is
+     * called when upstream changes re-evaluate to a different value.
+     *
+     * @param {string} paramName
+     * @param {() => void} listener
+     * @returns {() => void}
+     */
+    subscribe(paramName, listener) {
+        validateParameterName(paramName);
+        const runtime = this.findRuntimeForParam(paramName);
+        if (!runtime) {
+            throw new Error("Parameter not found: " + paramName);
+        }
+
+        const ref = runtime.#localRefs.get(paramName);
+        if (!ref) {
+            throw new Error(
+                "Parameter found without local reference: " + paramName
+            );
+        }
+
+        return ref.subscribe(listener);
+    }
+
+    /**
+     * Get the value of a parameter from this runtime or its ancestors.
+     * @param {string} paramName
+     */
+    findValue(paramName) {
+        const runtime = this.findRuntimeForParam(paramName);
+        return runtime?.getValue(paramName);
+    }
+
+    /**
+     * Returns configs for all parameters that have been registered using `registerParam`.
+     */
+    get paramConfigs() {
+        return /** @type {ReadonlyMap<string, Parameter>} */ (
+            this.#paramConfigs
+        );
+    }
+
+    /**
+     *
+     * @param {string} paramName
+     * @returns {ViewParamRuntime}
+     */
+    findRuntimeForParam(paramName) {
+        if (this.#localRefs.has(paramName)) {
+            return this;
+        } else {
+            return this.#parentFinder()?.findRuntimeForParam(paramName);
+        }
+    }
+
+    // Setter lifecycle is scope-owned: setters are dropped when the runtime scope
+    // is disposed. A standalone deallocation API is intentionally not exposed.
+
+    /**
+     * Parse expr and return a function that returns the value of the parameter.
+     *
+     * @param {string} expr
+     */
+    createExpression(expr) {
+        return this.#runtime.createExpression(this.#scopeId, expr);
+    }
+
+    /**
+     * Creates an expression and subscribes a listener that is automatically
+     * removed according to `options` lifecycle ownership.
+     *
+     * Lifecycle semantics:
+     * 1. `scopeOwned: true` (default): unsubscribe is bound to runtime scope
+     *    disposal (`ViewParamRuntime.dispose()`).
+     * 2. `scopeOwned: false`: caller must own teardown, typically via
+     *    `registerDisposer` or by storing and calling the returned unsubscribe.
+     * 3. `registerDisposer` can be used regardless of `scopeOwned` to bind the
+     *    same unsubscribe to another lifecycle owner.
+     *
+     * @param {string} expr
+     * @param {() => void} listener
+     * @param {WatchExpressionOptions} [options]
+     * @returns {ExprRefFunction}
+     */
+    watchExpression(expr, listener, options = {}) {
+        const fn = this.createExpression(expr);
+        const dispose = fn.subscribe(listener);
+
+        if (options.scopeOwned ?? true) {
+            this.#runtime.addScopeDisposer(this.#scopeId, dispose);
+        }
+        options.registerDisposer?.(dispose);
+
+        return fn;
+    }
+
+    /**
+     * @template T
+     * @param {string} name
+     * @param {T} defaultValue
+     * @returns {(value: T) => void}
+     */
+    #registerBaseSetter(name, defaultValue) {
+        const ref = this.#runtime.registerBase(
+            this.#scopeId,
+            name,
+            defaultValue
+        );
+        this.#localRefs.set(name, ref);
+        const setter = (
+            /** @type {T} */
+            value
+        ) => {
+            ref.set(value);
+            this.#runtime.flushNow();
+        };
+        this.#allocatedSetters.set(name, setter);
+        return setter;
+    }
+
+    /**
+     * A convenience method for evaluating an expression.
+     *
+     * @param {string} expr
+     */
+    evaluateAndGet(expr) {
+        const fn = this.createExpression(expr);
+        return fn();
+    }
+
+    /**
+     * @template T
+     * @param {() => T} fn
+     * @returns {T}
+     */
+    runInTransaction(fn) {
+        return this.#runtime.runInTransaction(fn);
+    }
+
+    flushNow() {
+        this.#runtime.flushNow();
+    }
+
+    /**
+     * Sync barrier only: resolves when DAG propagation/effects have flushed.
+     * Must not be broadened to temporal/animation convergence semantics.
+     *
+     * @param {{ signal?: AbortSignal, timeoutMs?: number }} [options]
+     */
+    whenPropagated(options) {
+        return this.#runtime.whenPropagated(options);
+    }
+
+    dispose() {
+        if (this.#disposed) {
+            return;
+        }
+
+        this.#disposed = true;
+        this.#runtime.disposeScope(this.#scopeId);
+        this.#allocatedSetters.clear();
+        this.#localRefs.clear();
+        this.#paramConfigs.clear();
+    }
+
+    /**
+     * Returns true if this runtime has any parameters that are point selections.
+     * Point selections necessitate the use of uniqueIds in the data.
+     *
+     * @returns {boolean}
+     */
+    hasPointSelections() {
+        for (const param of this.#paramConfigs.values()) {
+            if (isSelectionParameter(param)) {
+                const select = param.select;
+                if (isString(select)) {
+                    if (select == "point") {
+                        return true;
+                    }
+                } else if (select.type == "point") {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+}

package/dist/src/scale/scale.d.ts

@@ -6,5 +6,10 @@ export function configureScale(_: any, scale: any, logger: any): void;
  * @returns {import("../encoder/encoder.js").VegaScale}
  */
 export default function createScale(_: import("../spec/scale.js").Scale, logger: any): import("../encoder/encoder.js").VegaScale;
-export function configureDomain(scale: any, _: any, logger: any): any;
+export function configureDomain(scale: any, _: any, logger: any): {
+    domain: any;
+    count: any;
+    ordinalUnknown: any;
+    applyOrdinalUnknown: boolean;
+};
 //# sourceMappingURL=scale.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"scale.d.ts","sourceRoot":"","sources":["../../../src/scale/scale.js"],"names":[],"mappings":"AAoHA,sEAmBC;AAED;;;;;GAKG;AACH,uCAJW,OAAO,kBAAkB,EAAE,KAAK,UAChC,GAAC,GACC,OAAO,uBAAuB,EAAE,SAAS,CAoBrD;AAgCD,sEAuEC"}
+{"version":3,"file":"scale.d.ts","sourceRoot":"","sources":["../../../src/scale/scale.js"],"names":[],"mappings":"AAgIA,sEAuBC;AAED;;;;;GAKG;AACH,uCAJW,OAAO,kBAAkB,EAAE,KAAK,UAChC,GAAC,GACC,OAAO,uBAAuB,EAAE,SAAS,CAoBrD;AA4CD;;;;;EAuGC"}

package/dist/src/scale/scale.js

@@ -11,8 +11,20 @@
 /* eslint-disable */
 // @ts-nocheck
 
-// This file is a mess
-// TODO: Fix types, etc.
+/*
+ * Rewrite rationale (non-perf):
+ * - This module mixes spec-level policy, vega-scale helpers, and D3 scale
+ *   mutability. The combination works but is clunky to maintain and hard to
+ *   integrate with higher-level orchestration like ScaleResolution.
+ * - Side-effectful configuration and implicit defaults make the data flow
+ *   difficult to reason about and to test in isolation.
+ *
+ * Why not rewrite yet:
+ * - Behavior is subtle and well-tested; a rewrite is risky without a clear
+ *   contract for the pure inputs/outputs and their callers.
+ * - It depends on D3 scale semantics (copy, unknown, interpolate, etc.), so any
+ *   refactor must preserve those semantics explicitly.
+ */
 
 import { tickCount } from "./ticks.js";
 import {
@@ -128,11 +140,15 @@ export function configureScale(_, scale, logger) {
         }
     }
 
-    configureRange(
-        scale,
-        _,
-        configureBins(scale, _, configureDomain(scale, _, logger))
-    );
+    const domainConfig = configureDomain(scale, _, logger);
+    if (domainConfig.domain) {
+        scale.domain(domainConfig.domain);
+    }
+    if (domainConfig.applyOrdinalUnknown) {
+        scale.unknown(domainConfig.ordinalUnknown);
+    }
+
+    configureRange(scale, _, configureBins(scale, _, domainConfig.count));
 }
 
 /**
@@ -191,24 +207,62 @@ function isContinuousColor(_) {
     );
 }
 
+function copyScaleForDomain(scale) {
+    if (!scale.copy) {
+        return scale;
+    }
+
+    const copy = scale.copy();
+    if (copy.type == null && scale.type != null) {
+        copy.type = scale.type;
+    }
+    return copy;
+}
+
 export function configureDomain(scale, _, logger) {
     if (!scale.domain) {
-        return 0;
+        return {
+            domain: null,
+            count: 0,
+            ordinalUnknown: undefined,
+            applyOrdinalUnknown: false,
+        };
     }
 
     logger = ensureLogger(logger);
 
+    const workingScale = copyScaleForDomain(scale);
+
     // check raw domain, if provided use that and exit early
-    var raw = rawDomain(scale, _.domainRaw, logger);
-    if (raw > -1) return raw;
+    var raw = rawDomain(workingScale, _.domainRaw, logger);
+    if (raw > -1) {
+        return {
+            domain: workingScale.domain(),
+            count: raw,
+            ordinalUnknown:
+                workingScale.type === Ordinal
+                    ? _.domainImplicit
+                        ? scaleImplicit
+                        : undefined
+                    : undefined,
+            applyOrdinalUnknown: false,
+        };
+    }
 
     var domain = _.domain,
-        type = scale.type,
-        zero = _.zero || (_.zero === undefined && includeZero(scale)),
+        type = workingScale.type,
+        zero = _.zero || (_.zero === undefined && includeZero(workingScale)),
         n,
         mid;
 
-    if (!domain) return 0;
+    if (!domain) {
+        return {
+            domain: null,
+            count: 0,
+            ordinalUnknown: undefined,
+            applyOrdinalUnknown: false,
+        };
+    }
 
     // adjust continuous domain for minimum pixel padding
     if (includePad(type) && _.padding && domain[0] !== peek(domain)) {
@@ -247,21 +301,27 @@ export function configureDomain(scale, _, logger) {
     }
 
     // set the scale domain
-    scale.domain(domainCheck(type, domain, logger));
-
-    // if ordinal scale domain is defined, prevent implicit
-    // domain construction as side-effect of scale lookup
-    if (type === Ordinal) {
-        scale.unknown(_.domainImplicit ? scaleImplicit : undefined);
-    }
+    workingScale.domain(domainCheck(type, domain, logger));
 
     // perform 'nice' adjustment as requested
-    if (_.nice && scale.nice) {
-        scale.nice((_.nice !== true && tickCount(scale, _.nice)) || null);
+    if (_.nice && workingScale.nice) {
+        workingScale.nice(
+            (_.nice !== true && tickCount(workingScale, _.nice)) || null
+        );
     }
 
     // return the cardinality of the domain
-    return domain.length;
+    return {
+        domain: workingScale.domain(),
+        count: domain.length,
+        ordinalUnknown:
+            type === Ordinal
+                ? _.domainImplicit
+                    ? scaleImplicit
+                    : undefined
+                : undefined,
+        applyOrdinalUnknown: type === Ordinal,
+    };
 }
 
 function rawDomain(scale, raw, logger) {

package/dist/src/scales/axisResolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"axisResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/axisResolution.js"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH;IASI;;OAEG;IACH,qBAFW,OAAO,oBAAoB,EAAE,wBAAwB,EAI/D;IADG,+DAAsB;IAG1B,2BAGC;IAiCD;;;OAGG;IACH,uBAHW,oBAAoB,GAClB,MAAM,OAAO,CAQzB;IAED;;;OAGG;IACH,qBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED,qDAuBC;IAED,mBAyDC;;CACJ;iCAtK6D,CAAC,SAAlD,OAAQ,oBAAoB,EAAE,iBAAkB;UAGnD,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB"}
+{"version":3,"file":"axisResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/axisResolution.js"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH;IASI;;OAEG;IACH,qBAFW,OAAO,oBAAoB,EAAE,wBAAwB,EAI/D;IADG,+DAAsB;IAG1B,2BAGC;IAiCD;;;OAGG;IACH,uBAHW,oBAAoB,GAClB,MAAM,OAAO,CAQzB;IAED;;;OAGG;IACH,qBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED,qDAuBC;IAED,mBAmEC;;CACJ;iCAhL6D,CAAC,SAAlD,OAAQ,oBAAoB,EAAE,iBAAkB;UAGnD,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB"}

package/dist/src/scales/axisResolution.js

@@ -137,6 +137,9 @@ export default class AxisResolution {
 
             return {
                 member,
+                axisTitle:
+                    // TODO: Proper type guard
+                    "axis" in channelDef ? channelDef.axis?.title : undefined,
                 explicitTitle: coalesce(
                     // TODO: Proper type guard
                     "axis" in channelDef ? channelDef.axis?.title : undefined,
@@ -150,6 +153,13 @@ export default class AxisResolution {
         };
 
         const titles = Array.from(this.#members).map(computeTitle);
+        const explicitAxisTitle = titles
+            .map((title) => title.axisTitle)
+            .find((title) => title !== undefined);
+
+        if (explicitAxisTitle !== undefined) {
+            return explicitAxisTitle;
+        }
 
         // Skip implicit secondary channel titles if the primary channel has an explicit title
         const filteredTitles = titles.filter((title) => {

package/dist/src/scales/{scaleDomainAggregator.d.ts → domainPlanner.d.ts}

@@ -4,16 +4,18 @@
  * @typedef {import("../spec/scale.js").ScalarDomain} ScalarDomain
  * @typedef {import("./scaleResolution.js").ScaleResolutionMember} ScaleResolutionMember
  */
-export default class ScaleDomainAggregator {
+export default class DomainPlanner {
     /**
      * @param {object} options
      * @param {() => Set<ScaleResolutionMember>} options.getMembers
+     * @param {() => Set<ScaleResolutionMember>} [options.getDataMembers]
      * @param {() => import("../spec/channel.js").Type} options.getType
      * @param {() => number[]} options.getLocusExtent
      * @param {(interval: ScalarDomain | ComplexDomain) => number[]} options.fromComplexInterval
      */
-    constructor({ getMembers, getType, getLocusExtent, fromComplexInterval }: {
+    constructor({ getMembers, getDataMembers, getType, getLocusExtent, fromComplexInterval, }: {
         getMembers: () => Set<ScaleResolutionMember>;
+        getDataMembers?: () => Set<ScaleResolutionMember>;
         getType: () => import("../spec/channel.js").Type;
         getLocusExtent: () => number[];
         fromComplexInterval: (interval: ScalarDomain | ComplexDomain) => number[];
@@ -23,6 +25,7 @@ export default class ScaleDomainAggregator {
      */
     get initialDomainSnapshot(): any[];
     hasConfiguredDomain(): boolean;
+    invalidateConfiguredDomain(): void;
     /**
      * Returns the configured domain or a data-derived/default domain.
      *
@@ -54,4 +57,4 @@ export type DomainArray = import("../utils/domainArray.js").DomainArray;
 export type ComplexDomain = import("../spec/scale.js").ComplexDomain;
 export type ScalarDomain = import("../spec/scale.js").ScalarDomain;
 export type ScaleResolutionMember = import("./scaleResolution.js").ScaleResolutionMember;
-//# sourceMappingURL=scaleDomainAggregator.d.ts.map
+//# sourceMappingURL=domainPlanner.d.ts.map

package/dist/src/scales/domainPlanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domainPlanner.d.ts","sourceRoot":"","sources":["../../../src/scales/domainPlanner.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AAEH;IA2BI;;;;;;;OAOG;IACH,2FANG;QAAkD,UAAU,EAApD,MAAM,GAAG,CAAC,qBAAqB,CAAC;QACW,cAAc,GAAzD,MAAM,GAAG,CAAC,qBAAqB,CAAC;QACiB,OAAO,EAAxD,MAAM,OAAO,oBAAoB,EAAE,IAAI;QACf,cAAc,EAAtC,MAAM,MAAM,EAAE;QACgD,mBAAmB,EAAjF,CAAC,QAAQ,EAAE,YAAY,GAAG,aAAa,KAAK,MAAM,EAAE;KAC9D,EAaA;IAED;;OAEG;IACH,6BAFa,GAAG,EAAE,CAIjB;IAED,+BAEC;IAED,mCAEC;IAED;;;;;OAKG;IACH,iDAHW,OAAO,GACL,GAAG,EAAE,CAYjB;IAED;;;;OAIG;IACH,uBAFY,WAAW,CActB;IAED;;;;OAIG;IACH,iBAFY,WAAW,GAAG,SAAS,CAQlC;IAED;;;;OAIG;IACH,4BAJW,OAAO,qBAAqB,EAAE,SAAS,wBACvC,OAAO,GACL,OAAO,CAgBnB;;CAkCJ;0BA7KY,OAAO,yBAAyB,EAAE,WAAW;4BAC7C,OAAO,kBAAkB,EAAE,aAAa;2BACxC,OAAO,kBAAkB,EAAE,YAAY;oCACvC,OAAO,sBAAsB,EAAE,qBAAqB"}