@genome-spy/core 0.73.0 → 0.75.0

package/dist/src/utils/expression.js

@@ -6,7 +6,9 @@ import {
     isObject,
     isRegExp,
     isString,
+    ascending,
     lerp,
+    span,
 } from "vega-util";
 import { format as d3format } from "d3-format";
 import smoothstep from "./smoothstep.js";
@@ -15,12 +17,63 @@ import linearstep from "./linearstep.js";
 
 /**
  * Some bits are adapted from https://github.com/vega/vega/blob/main/packages/vega-functions/src/codegen.js
+ *
+ * @param {unknown} value
+ * @returns {any}
+ */
+function array(value) {
+    return isArray(value) || ArrayBuffer.isView(value) ? value : null;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {any}
  */
+function sequence(value) {
+    return array(value) || (isString(value) ? value : null);
+}
+
 const functionContext = {
     clamp,
     format(/** @type {number} */ value, /** @type {string} */ format) {
         return d3format(format)(value);
     },
+    /**
+     * Vega's expression docs list these as basic sequence helpers, but the
+     * bundled `vega-expression` version does not currently include them in the
+     * codegen whitelist. Implement them here so specs can rely on them.
+     */
+    join(/** @type {any} */ seq, /** @type {string} */ separator) {
+        return array(seq).join(separator);
+    },
+
+    indexof(
+        /** @type {any} */ seq,
+        /** @type {any} */ value,
+        /** @type {number | undefined} */ start
+    ) {
+        return sequence(seq).indexOf(value, start);
+    },
+
+    lastindexof(
+        /** @type {any} */ seq,
+        /** @type {any} */ value,
+        /** @type {number | undefined} */ start
+    ) {
+        return sequence(seq).lastIndexOf(value, start);
+    },
+
+    reverse(/** @type {any} */ seq) {
+        return array(seq).slice().reverse();
+    },
+
+    slice(
+        /** @type {any} */ seq,
+        /** @type {number} */ start,
+        /** @type {number | undefined} */ end
+    ) {
+        return sequence(seq).slice(start, end);
+    },
     mapHasKey(/** @type {Map<any, any>} */ map, /** @type {any} */ key) {
         return map.has(key);
     },
@@ -34,7 +87,6 @@ const functionContext = {
     isRegExp,
     isString,
     isValid(/** @type {any} */ _) {
-        // eslint-disable-next-line no-self-compare
         return _ != null && _ === _;
     },
     lerp,
@@ -46,46 +98,320 @@ const functionContext = {
     ) {
         return String(str).replace(pattern, replace);
     },
+    sort(/** @type {Array<any>} */ seq) {
+        return array(seq).slice().sort(ascending);
+    },
+    /**
+     * Returns the midpoint of an ordered extent, such as [min, max].
+     * The helper uses the first and last elements and does not sort.
+     */
+    center(/** @type {Array<any>} */ seq) {
+        const values = array(seq);
+        return (values[0] + values[values.length - 1]) / 2;
+    },
+    span(/** @type {Array<any>} */ seq) {
+        return span(seq);
+    },
     smoothstep,
 };
 
 /**
  * @param {typeof codegenExpression} codegen
+ * @param {ScaleHelperCompileContext} context
  */
-function buildFunctions(codegen) {
-    const fn = functions(codegen);
-    // eslint-disable-next-line guard-for-in
+function buildFunctions(codegen, context) {
+    const fn = /** @type {any} */ (functions(codegen));
     for (const name in functionContext) {
         fn[name] = `this.${name}`;
     }
+
+    // Replace the public helper names with custom codegen hooks so we can bind
+    // a scale resolution once during compilation instead of looking it up for
+    // every datum.
+    for (const kind of /** @type {const} */ ([
+        "scale",
+        "invert",
+        "domain",
+        "range",
+    ])) {
+        fn[kind] = (
+            /** @type {any[]} */
+            args
+        ) => buildScaleHelperCall(codegen, context, kind, args);
+    }
+
     return fn;
 }
 
-const cg = codegenExpression({
-    forbidden: [],
-    allowed: ["datum", "undefined"],
-    globalvar: "globalObject",
-    fieldvar: "datum",
-    functions: buildFunctions,
-});
-
 /**
  * @typedef { object } ExpressionProps
  * @prop { string[] } fields
  * @prop { string[] } globals
  * @prop { string } code
+ * @prop { import("../paramRuntime/types.js").ParamRef<any>[] } [scaleDependencies]
  *
  * @typedef { ((datum?: import("../data/flowNode.js").Datum) => any) & ExpressionProps } ExpressionFunction
  *
+ * @typedef {object} ExpressionCompileContext
+ * @prop {(channel: string) => import("../scales/scaleResolution.js").default | undefined} [resolveScaleResolution]
+ *
+ * @typedef {ExpressionCompileContext & {
+ *   globalvar: string,
+ *   globalObject: Record<string, any>,
+ *   getScaleHelper: (kind: "scale" | "invert" | "domain" | "range", channel: string, resolution: import("../scales/scaleResolution.js").default) => { codeName: string, dependency: import("../paramRuntime/types.js").ParamRef<any> }
+ * }} ScaleHelperCompileContext
+ */
+
+/**
+ * @param {typeof codegenExpression} codegen
+ * @param {ScaleHelperCompileContext} context
+ * @param {"scale" | "invert" | "domain" | "range"} kind
+ * @param {any[]} args
+ * @returns {string}
+ */
+function buildScaleHelperCall(codegen, context, kind, args) {
+    if (args.length === 0) {
+        throw new Error(
+            `Scale helper "${kind}" requires a literal channel name.`
+        );
+    }
+
+    if ((kind === "scale" || kind === "invert") && args.length < 2) {
+        throw new Error(
+            `Scale helper "${kind}" requires a channel name and a value.`
+        );
+    }
+
+    const channel = getLiteralString(args[0]);
+    if (!channel) {
+        throw new Error(
+            `Scale helper "${kind}" requires a literal channel name.`
+        );
+    }
+
+    const resolution = context.resolveScaleResolution?.(channel);
+    if (!resolution) {
+        throw new Error(
+            `Unknown scale channel "${channel}" in expression helper "${kind}".`
+        );
+    }
+
+    const helper = context.getScaleHelper(kind, channel, resolution);
+    const remainingArgs = args
+        .slice(1)
+        .map((arg) => codegen(arg))
+        .join(",");
+    return `${context.globalvar}["${helper.codeName}"](${remainingArgs})`;
+}
+
+/**
+ * @param {any} node
+ * @returns {string | undefined}
+ */
+function getLiteralString(node) {
+    return node?.type === "Literal" && typeof node.value === "string"
+        ? node.value
+        : undefined;
+}
+
+/**
+ * @param {"scale" | "invert" | "domain" | "range"} kind
+ * @param {import("../scales/scaleResolution.js").default} resolution
+ * @returns {(...args: any[]) => any}
+ */
+function createScaleHelperFunction(kind, resolution) {
+    /** @type {(fn: () => any) => any} */
+    const run = (fn) => runWithActiveScaleResolution(resolution, kind, fn);
+
+    if (kind === "domain") {
+        // `vega-scale` returns a fresh array here. That is fine for
+        // batch-invariant expressions, but callers should avoid using it in a
+        // per-datum hot path unless they really need the full extent array.
+        return () => run(() => resolution.getDomain());
+    }
+    if (kind === "range") {
+        // Same allocation caveat as `domain()`: the underlying scale getter
+        // returns a copied array, so repeated per-row calls will allocate.
+        return () => run(() => resolution.getScale().range());
+    }
+    if (kind === "scale") {
+        return (value) => run(() => resolution.getScale()(value));
+    }
+    if (kind === "invert") {
+        return (value) =>
+            run(() => /** @type {any} */ (resolution.getScale()).invert(value));
+    }
+    throw new Error("Unknown scale helper: " + kind);
+}
+
+/** @type {WeakSet<object>} */
+const activeScaleHelperResolutions = new WeakSet();
+
+/**
+ * @template T
+ * @param {import("../scales/scaleResolution.js").default} resolution
+ * @param {"scale" | "invert" | "domain" | "range"} kind
+ * @param {() => T} fn
+ * @returns {T}
+ */
+function runWithActiveScaleResolution(resolution, kind, fn) {
+    if (activeScaleHelperResolutions.has(resolution)) {
+        throw new Error(
+            `Scale helper cycle detected while evaluating ${kind}("${resolution.channel}").`
+        );
+    }
+
+    activeScaleHelperResolutions.add(resolution);
+    try {
+        return fn();
+    } finally {
+        activeScaleHelperResolutions.delete(resolution);
+    }
+}
+
+/**
+ * @param {"scale" | "invert" | "domain" | "range"} kind
+ * @param {string} channel
+ * @param {import("../scales/scaleResolution.js").default} resolution
+ * @param {string} codeName
+ * @returns {import("../paramRuntime/types.js").ParamRef<any> & { rank: number }}
+ */
+function createScaleDependency(kind, channel, resolution, codeName) {
+    /** @type {Set<() => void>} */
+    const listeners = new Set();
+
+    const notify = () => {
+        for (const listener of listeners) {
+            listener();
+        }
+    };
+
+    const attach = () => {
+        if (kind === "domain") {
+            resolution.addEventListener("domain", notify);
+        } else if (kind === "range") {
+            resolution.addEventListener("range", notify);
+        } else {
+            resolution.addEventListener("domain", notify);
+            resolution.addEventListener("range", notify);
+        }
+    };
+
+    const detach = () => {
+        if (kind === "domain") {
+            resolution.removeEventListener("domain", notify);
+        } else if (kind === "range") {
+            resolution.removeEventListener("range", notify);
+        } else {
+            resolution.removeEventListener("domain", notify);
+            resolution.removeEventListener("range", notify);
+        }
+    };
+
+    return {
+        // The dependency is a lightweight invalidation token. It does not need
+        // to expose a separate scale value; the bound helper closure already
+        // closes over the actual resolution. The ref exists so the expression
+        // graph can subscribe to scale changes like any other reactive input.
+        id: `scale:${channel}:${codeName}`,
+        name: `scale(${channel})`,
+        kind: "derived",
+        rank: 0,
+        get() {
+            return resolution.getScale();
+        },
+        subscribe(listener) {
+            const wasEmpty = listeners.size === 0;
+            listeners.add(listener);
+            if (wasEmpty) {
+                attach();
+            }
+            return () => {
+                const removed = listeners.delete(listener);
+                if (removed && listeners.size === 0) {
+                    detach();
+                }
+            };
+        },
+    };
+}
+
+/**
  * @param {string} expr
+ * @param {Record<string, any>} globalObject
+ * @param {ExpressionCompileContext} context
+ *
  * @returns {ExpressionFunction}
  */
-export default function createFunction(expr, globalObject = {}) {
+export default function createFunction(expr, globalObject = {}, context = {}) {
     try {
+        // Each scale helper call is rewritten once at compile time into a
+        // cached closure that targets a specific scale resolution.
+        /** @type {Map<string, import("../paramRuntime/types.js").ParamRef<any>>} */
+        const scaleDependenciesByChannel = new Map();
+        // A helper may appear multiple times in one expression. Cache both the
+        // generated closure and the synthetic dependency ref so repeated calls
+        // share the same reactive identity.
+        /** @type {Map<string, { codeName: string, dependency: import("../paramRuntime/types.js").ParamRef<any> }>} */
+        const helperEntries = new Map();
+        let nextScaleHelperId = 1;
+
+        /**
+         * @type {ExpressionCompileContext & {
+         *   globalvar: string,
+         *   globalObject: Record<string, any>,
+         *   getScaleHelper: (kind: "scale" | "invert" | "domain" | "range", channel: string, resolution: import("../scales/scaleResolution.js").default) => { codeName: string, dependency: import("../paramRuntime/types.js").ParamRef<any> }
+         * }}
+         */
+        const helperContext = {
+            ...context,
+            globalvar: "globalObject",
+            globalObject,
+            getScaleHelper(kind, channel, resolution) {
+                // Helper instances are keyed by helper kind + channel so
+                // `domain("x")` and `scale("x", ...)` share the same
+                // resolution binding but keep separate generated closures.
+                const key = kind + ":" + channel;
+                const cached = helperEntries.get(key);
+                if (cached) {
+                    return cached;
+                }
+
+                let dependency = scaleDependenciesByChannel.get(channel);
+                if (!dependency) {
+                    dependency = createScaleDependency(
+                        kind,
+                        channel,
+                        resolution,
+                        "__scale_dependency_" + nextScaleHelperId++
+                    );
+                    scaleDependenciesByChannel.set(channel, dependency);
+                }
+
+                const codeName = "__scale_helper_" + nextScaleHelperId++;
+                const entry = { codeName, dependency };
+                helperEntries.set(key, entry);
+                // Store the concrete helper implementation on the global object
+                // used by the generated expression function.
+                globalObject[codeName] = createScaleHelperFunction(
+                    kind,
+                    resolution
+                );
+                return entry;
+            },
+        };
+
+        const cg = codegenExpression({
+            forbidden: [],
+            allowed: ["datum", "undefined"],
+            globalvar: "globalObject",
+            fieldvar: "datum",
+            functions: (visitor) => buildFunctions(visitor, helperContext),
+        });
+
         const parsed = parseExpression(expr);
         const generatedCode = cg(parsed);
 
-        // eslint-disable-next-line no-new-func
         const fn = Function(
             "datum",
             "globalObject",
@@ -105,10 +431,18 @@ export default function createFunction(expr, globalObject = {}) {
         exprFunction.fields = generatedCode.fields;
         exprFunction.globals = generatedCode.globals;
         exprFunction.code = generatedCode.code;
+        // Reactive bookkeeping lives outside the generated expression body.
+        // The expression runtime subscribes to these refs and invalidates the
+        // compiled expression when the referenced scale changes.
+        exprFunction.scaleDependencies = Array.from(
+            scaleDependenciesByChannel.values()
+        );
 
         return exprFunction;
     } catch (e) {
-        throw new Error(`Invalid expression: ${expr}, ${e.message}`);
+        throw new Error(`Invalid expression: ${expr}, ${e.message}`, {
+            cause: e,
+        });
     }
 }
 
@@ -120,14 +454,13 @@ const eventFilterCg = codegenExpression({
 
 /**
  * @param {string} expr
- * @returns {(event: UIEvent) => boolean}
+ * @returns {(event: UIEvent | import("./interactionEvent.js").WheelLikeEvent) => boolean}
  */
 export function createEventFilterFunction(expr) {
     try {
         const parsed = parseExpression(expr);
         const generatedCode = eventFilterCg(parsed);
 
-        // eslint-disable-next-line no-new-func
         const fn = Function(
             "event",
             "globalObject",
@@ -141,10 +474,12 @@ export function createEventFilterFunction(expr) {
             }`
         );
 
-        return /** @type {(event: UIEvent) => boolean} */ (
+        return /** @type {(event: UIEvent | import("./interactionEvent.js").WheelLikeEvent) => boolean} */ (
             /** @type {any} */ (fn)
         );
     } catch (e) {
-        throw new Error(`Invalid expression: ${expr}, ${e.message}`);
+        throw new Error(`Invalid expression: ${expr}, ${e.message}`, {
+            cause: e,
+        });
     }
 }

package/dist/src/utils/field.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../../src/utils/field.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,iCAHW,MAAM,SACN,MAAM,uCAgChB"}
+{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../../src/utils/field.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,iCAHW,MAAM,SACN,MAAM,uCA+BhB"}

package/dist/src/utils/field.js

@@ -25,7 +25,6 @@ export function field(fieldExpr, name = fieldExpr) {
             }
         };
 
-        // eslint-disable-next-line no-new-func
         const fn = /** @type {import("vega-util").AccessorFn} */ (
             new Function(
                 "validator",

package/dist/src/utils/inertia.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inertia.d.ts","sourceRoot":"","sources":["../../../src/utils/inertia.js"],"names":[],"mappings":"AAwEA;;;GAGG;AACH,kCAFa,CAAC,SADH,CAAC,iCAoBX;AAzFD;;GAEG;AACH;IACI;;;OAGG;IACH,sBAHW,OAAO,eAAe,EAAE,OAAO,aAC/B,OAAO,EA0BjB;IAvBG,0CAAwB;IACxB,kBAA0B;IAG1B,oBAAsB;IAEtB,oCAAoC;IACpC,UADW,CAAS,IAAM,EAAN,MAAM,KAAE,IAAI,CACZ;IAEpB,oBAAoB;IACpB,kBAAkB;IAElB;;;;MAUC;IAGL,eAQC;IAED;;;;OAIG;IACH,mBAHW,MAAM,YACN,CAAS,IAAM,EAAN,MAAM,KAAE,IAAI,QAkB/B;CACJ"}
+{"version":3,"file":"inertia.d.ts","sourceRoot":"","sources":["../../../src/utils/inertia.js"],"names":[],"mappings":"AAwEA;;;GAGG;AACH,kCAFa,CAAC,SADH,CAAC,iCAmBX;AAxFD;;GAEG;AACH;IACI;;;OAGG;IACH,sBAHW,OAAO,eAAe,EAAE,OAAO,aAC/B,OAAO,EA0BjB;IAvBG,0CAAwB;IACxB,kBAA0B;IAG1B,oBAAsB;IAEtB,oCAAoC;IACpC,UADW,CAAS,IAAM,EAAN,MAAM,KAAE,IAAI,CACZ;IAEpB,oBAAoB;IACpB,kBAAkB;IAElB;;;;MAUC;IAGL,eAQC;IAED;;;;OAIG;IACH,mBAHW,MAAM,YACN,CAAS,IAAM,EAAN,MAAM,KAAE,IAAI,QAkB/B;CACJ"}

package/dist/src/utils/inertia.js

@@ -80,7 +80,6 @@ export function makeEventTemplate(event) {
     const acceptedTypes = ["string", "number", "boolean"];
     const rejectedProps = ["wheelDelta", "wheelDeltaX", "wheelDeltaY"];
 
-    // eslint-disable-next-line guard-for-in
     for (const key in event) {
         const k = /** @type {keyof T} */ (key);
         if (

package/dist/src/utils/inputBinding.d.ts

@@ -9,5 +9,5 @@ export default function createBindingInputs(mediator: {
     paramConfigs: ReadonlyMap<string, import("../spec/parameter.js").Parameter>;
     setValue: (name: string, value: any) => void;
     getValue: (name: string) => any;
-}): import("lit-html").TemplateResult<2 | 1 | 3>[];
+}): import("lit-html").TemplateResult<1 | 2 | 3>[];
 //# sourceMappingURL=inputBinding.d.ts.map

package/dist/src/utils/interaction.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Internal event object used by GenomeSpy's canvas interaction pipeline.
+ *
+ * Interaction is deliberately smaller than DOM Event. It models the pieces
+ * that GenomeSpy needs for hierarchical pointer handling:
+ * - `point` is always in canvas coordinates
+ * - `uiEvent` is the original native or synthesized low-level event
+ * - `target` is the resolved deepest view target after propagation
+ * - `currentTarget` and `relatedTarget` are used by synthesized
+ *   `mouseenter` / `mouseleave` delivery
+ *
+ * Runtime flow:
+ * 1. `InteractionController` converts native canvas events into Interaction
+ *    instances and asks `InteractionDispatcher` to route them.
+ * 2. Container views route the interaction through the view hierarchy and may
+ *    add policy on top, such as wheel claiming, zoom handling, or scrollbar
+ *    dispatch.
+ * 3. `InteractionDispatcher` compares successive hover paths and synthesizes
+ *    subtree-level `mouseenter` / `mouseleave` transitions.
+ *
+ * Differences from the DOM model:
+ * - propagation is view-driven rather than browser-driven
+ * - only the event types used by GenomeSpy are represented
+ * - there is only `stopPropagation()`, not stop-immediate semantics
+ * - mark picking is not encoded into `target`; mark hover lives separately in
+ *   `InteractionController`
+ *
+ * Mouse and wheel helpers:
+ * - `mouseEvent` exposes the underlying MouseEvent for imperative handlers
+ * - `proxiedMouseEvent` exposes only primitive properties for places that
+ *   must not retain live DOM objects
+ * - `wheelEvent` exposes the underlying wheel-like event, optionally with
+ *   temporary delta overrides applied by `setWheelDeltas()`
+ *
+ * Special event types:
+ * - `wheelclaimprobe` asks pointed views whether they would consume wheel,
+ *   without running the actual wheel side effects yet
+ * - `touchgesture` is a synthesized high-level gesture event derived from
+ *   touch input
+ */
+export default class Interaction {
+    /**
+     * @param {import("../view/layout/point.js").default} point
+     * @param {import("./interactionEvent.js").InteractionUiEvent} uiEvent
+     * @param {string} [type]
+     */
+    constructor(point: import("../view/layout/point.js").default, uiEvent: import("./interactionEvent.js").InteractionUiEvent, type?: string);
+    point: import("../view/layout/point.js").default;
+    stopped: boolean;
+    wheelClaimed: boolean;
+    /**
+     * The target is known only after the interaction has been resolved
+     * against the view hierarchy.
+     *
+     * @type {import("../view/view.js").default | undefined}
+     */
+    target: import("../view/view.js").default | undefined;
+    /**
+     * Reserved for the new interaction dispatcher.
+     *
+     * @type {import("../view/view.js").default | undefined}
+     */
+    currentTarget: import("../view/view.js").default | undefined;
+    /**
+     * Reserved for enter/leave-style transition events.
+     *
+     * @type {import("../view/view.js").default | undefined}
+     */
+    relatedTarget: import("../view/view.js").default | undefined;
+    set uiEvent(value: import("./interactionEvent.js").InteractionUiEvent);
+    get uiEvent(): import("./interactionEvent.js").InteractionUiEvent;
+    stopPropagation(): void;
+    /**
+     * Marks the current wheel interaction as claimed by the pointed view
+     * hierarchy.
+     *
+     * This is used both for real wheel events and for the synthetic
+     * `wheelclaimprobe` preflight. Controllers use the claimed state to decide
+     * whether the native wheel event should call `preventDefault()`.
+     */
+    claimWheel(): void;
+    /**
+     * @param {number} deltaX
+     * @param {number} deltaY
+     */
+    setWheelDeltas(deltaX: number, deltaY: number): void;
+    set type(value: string);
+    get type(): string;
+    /**
+     * Returns a primitive-only proxy of the underlying MouseEvent.
+     *
+     * This is intended for places such as expression evaluation, where the
+     * caller needs scalar event fields but should not receive a live DOM event
+     * object with methods, nested objects, or browser-specific prototypes.
+     */
+    get proxiedMouseEvent(): MouseEvent;
+    get mouseEvent(): MouseEvent;
+    /**
+     * Returns a wheel-like event with any temporary delta overrides applied.
+     *
+     * The wrapped event keeps the original event identity for all properties
+     * except `deltaX` and `deltaY`, which allows intermediate handlers to
+     * consume part of the wheel interaction while keeping downstream wheel
+     * handling on the same event instance.
+     */
+    get wheelEvent(): Pick<WheelEvent, "type" | "deltaX" | "deltaY" | "deltaMode" | "preventDefault" | "ctrlKey">;
+    #private;
+}
+//# sourceMappingURL=interaction.d.ts.map

package/dist/src/utils/interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../../src/utils/interaction.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IAOI;;;;OAIG;IACH,mBAJW,OAAO,yBAAyB,EAAE,OAAO,WACzC,OAAO,uBAAuB,EAAE,kBAAkB,SAClD,MAAM,EA8BhB;IA3BG,iDAAkB;IAElB,iBAAoB;IACpB,sBAAyB;IAGzB;;;;;OAKG;IACH,QAFU,OAAO,iBAAiB,EAAE,OAAO,GAAG,SAAS,CAEhC;IAEvB;;;;OAIG;IACH,eAFU,OAAO,iBAAiB,EAAE,OAAO,GAAG,SAAS,CAEzB;IAE9B;;;;OAIG;IACH,eAFU,OAAO,iBAAiB,EAAE,OAAO,GAAG,SAAS,CAEzB;IAclC,uEAKC;IATD,kEAEC;IASD,wBAEC;IAED;;;;;;;OAOG;IACH,mBAMC;IAED;;;OAGG;IACH,uBAHW,MAAM,UACN,MAAM,QAShB;IAMD,wBAEC;IAND,mBAEC;IAMD;;;;;;OAMG;IACH,oCAQC;IAED,6BAMC;IAED;;;;;;;OAOG;IACH,8GAkBC;;CACJ"}