@genome-spy/core 0.73.0 → 0.75.0

package/dist/src/view/interactionRouting.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Runs the shared capture/body/bubble interaction frame for a container view.
+ *
+ * @param {import("./view.js").default} view
+ * @param {import("../utils/interaction.js").default} event
+ * @param {() => void} handler
+ */
+export function propagateInteraction(view: import("./view.js").default, event: import("../utils/interaction.js").default, handler: () => void): void;
+/**
+ * Propagates an interaction to a single hit-tested surface and optionally runs
+ * a follow-up action such as zoom handling.
+ *
+ * @param {import("../utils/interaction.js").default} event
+ * @param {() => boolean} hitTest
+ * @param {() => void} propagate
+ * @param {() => void} [afterPropagate]
+ * @returns {boolean}
+ */
+export function propagateInteractionSurface(event: import("../utils/interaction.js").default, hitTest: () => boolean, propagate: () => void, afterPropagate?: () => void): boolean;
+//# sourceMappingURL=interactionRouting.d.ts.map

package/dist/src/view/interactionRouting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactionRouting.d.ts","sourceRoot":"","sources":["../../../src/view/interactionRouting.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,2CAJW,OAAO,WAAW,EAAE,OAAO,SAC3B,OAAO,yBAAyB,EAAE,OAAO,WACzC,MAAM,IAAI,QAgBpB;AAED;;;;;;;;;GASG;AACH,mDANW,OAAO,yBAAyB,EAAE,OAAO,WACzC,MAAM,OAAO,aACb,MAAM,IAAI,mBACV,MAAM,IAAI,GACR,OAAO,CAqBnB"}

package/dist/src/view/interactionRouting.js

@@ -0,0 +1,53 @@
+/**
+ * Runs the shared capture/body/bubble interaction frame for a container view.
+ *
+ * @param {import("./view.js").default} view
+ * @param {import("../utils/interaction.js").default} event
+ * @param {() => void} handler
+ */
+export function propagateInteraction(view, event, handler) {
+    view.handleInteraction(event, true);
+
+    if (event.stopped) {
+        return;
+    }
+
+    handler();
+
+    if (event.stopped) {
+        return;
+    }
+
+    view.handleInteraction(event, false);
+}
+
+/**
+ * Propagates an interaction to a single hit-tested surface and optionally runs
+ * a follow-up action such as zoom handling.
+ *
+ * @param {import("../utils/interaction.js").default} event
+ * @param {() => boolean} hitTest
+ * @param {() => void} propagate
+ * @param {() => void} [afterPropagate]
+ * @returns {boolean}
+ */
+export function propagateInteractionSurface(
+    event,
+    hitTest,
+    propagate,
+    afterPropagate
+) {
+    if (!hitTest()) {
+        return false;
+    }
+
+    propagate();
+
+    if (event.stopped) {
+        return true;
+    }
+
+    afterPropagate?.();
+
+    return true;
+}

package/dist/src/view/layerView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layerView.d.ts","sourceRoot":"","sources":["../../../src/view/layerView.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,+BAHoD,KAAK,SAA5C,OAAQ,iBAAiB,EAAE,SAAU;IAW9C;;;;;;;;OAQG;IACH,kBAPW,KAAK,WACL,OAAO,yBAAyB,EAAE,OAAO,gBACzC,aAAa,cACb,OAAO,WAAW,EAAE,OAAO,QAC3B,MAAM,YACN,OAAO,WAAW,EAAE,WAAW,EAWzC;IAkCD;;;;;;OAMG;IACH,wBAJW,OAAO,iBAAiB,EAAE,SAAS,GAAG,OAAO,iBAAiB,EAAE,QAAQ,GAAG,OAAO,iBAAiB,EAAE,UAAU,UAC/G,MAAM,GACJ,OAAO,CAAC,SAAS,GAAG,OAAO,eAAe,EAAE,OAAO,CAAC,CAMhE;IAED;;;;OAIG;IACH,qBAFW,MAAM,iBAIhB;IA6CD,yIAEC;;CA6CJ;0BAtLyB,oBAAoB"}
+{"version":3,"file":"layerView.d.ts","sourceRoot":"","sources":["../../../src/view/layerView.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,+BAHoD,KAAK,SAA5C,OAAQ,iBAAiB,EAAE,SAAU;IAW9C;;;;;;;;OAQG;IACH,kBAPW,KAAK,WACL,OAAO,yBAAyB,EAAE,OAAO,gBACzC,aAAa,cACb,OAAO,WAAW,EAAE,OAAO,QAC3B,MAAM,YACN,OAAO,WAAW,EAAE,WAAW,EAQzC;IAqCD;;;;;;OAMG;IACH,wBAJW,OAAO,iBAAiB,EAAE,SAAS,GAAG,OAAO,iBAAiB,EAAE,QAAQ,GAAG,OAAO,iBAAiB,EAAE,UAAU,UAC/G,MAAM,GACJ,OAAO,CAAC,SAAS,GAAG,OAAO,eAAe,EAAE,OAAO,CAAC,CAMhE;IAED;;;;OAIG;IACH,qBAFW,MAAM,iBAIhB;IAgDD,yIAEC;;CA6CJ;0BAzLyB,oBAAoB"}

package/dist/src/view/layerView.js

@@ -26,10 +26,7 @@ export default class LayerView extends ContainerView {
      * @param {import("./view.js").ViewOptions} [options]
      */
     constructor(spec, context, layoutParent, dataParent, name, options) {
-        super(spec, context, layoutParent, dataParent, name, {
-            layersChildren: true,
-            ...options,
-        });
+        super(spec, context, layoutParent, dataParent, name, options);
 
         this.spec = spec;
 
@@ -61,6 +58,9 @@ export default class LayerView extends ContainerView {
                                     );
                                     // TODO: Add view to exception
                                 }
+                            },
+                            {
+                                layoutSizeParams: "inherit",
                             }
                         )
                     )
@@ -130,6 +130,9 @@ export default class LayerView extends ContainerView {
                 this.#children.splice(index, 1);
             },
             defaultName: () => this.getNextAutoName("layer"),
+            createViewOptions: {
+                layoutSizeParams: "inherit",
+            },
         });
     }
 
@@ -168,16 +171,16 @@ export default class LayerView extends ContainerView {
     }
 
     /**
-     * @param {import("../utils/interactionEvent.js").default} event
+     * @param {import("../utils/interaction.js").default} event
      */
-    propagateInteractionEvent(event) {
-        this.handleInteractionEvent(undefined, event, true);
+    propagateInteraction(event) {
+        this.handleInteraction(event, true);
         for (let i = this.#children.length - 1; i >= 0; i--) {
-            this.#children[i].propagateInteractionEvent(event);
+            this.#children[i].propagateInteraction(event);
             if (event.stopped) {
                 return;
             }
         }
-        this.handleInteractionEvent(undefined, event, false);
+        this.handleInteraction(event, false);
     }
 }

package/dist/src/view/layout/grid.js

@@ -67,7 +67,7 @@ export default class Grid {
      * @param {number} row
      */
     getCellIndex(col, row) {
-        let i = 0;
+        let i;
 
         if (this.maxCols == Infinity) {
             i = row == 0 ? col : undefined;

package/dist/src/view/renderingContext/bufferedViewRenderingContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bufferedViewRenderingContext.d.ts","sourceRoot":"","sources":["../../../../src/view/renderingContext/bufferedViewRenderingContext.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AAEH;;;GAGG;AACH;IA2BI;;;OAGG;IACH,2BAHW,OAAO,0BAA0B,EAAE,sBAAsB,mBACzD,4BAA4B,EActC;IAyCD;;;OAGG;IACH,eAmCC;;CA8EJ;;iBArNS,OAAO,yBAAyB,EAAE,OAAO;;;;gBACzC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC;sBAC/B,MAAM;sBACN,OAAO,SAAS,EAAE,eAAe;;;;;iBACjC,MAAM;;iCATiB,2BAA2B"}
+{"version":3,"file":"bufferedViewRenderingContext.d.ts","sourceRoot":"","sources":["../../../../src/view/renderingContext/bufferedViewRenderingContext.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AAEH;;;GAGG;AACH;IA2BI;;;OAGG;IACH,2BAHW,OAAO,0BAA0B,EAAE,sBAAsB,mBACzD,4BAA4B,EActC;IAyCD;;;OAGG;IACH,eAmCC;;CA4EJ;;iBAnNS,OAAO,yBAAyB,EAAE,OAAO;;;;gBACzC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC;sBAC/B,MAAM;sBACN,OAAO,SAAS,EAAE,eAAe;;;;;iBACjC,MAAM;;iCATiB,2BAA2B"}

package/dist/src/view/renderingContext/bufferedViewRenderingContext.js

@@ -183,7 +183,6 @@ export default class BufferedViewRenderingContext extends ViewRenderingContext {
                 continue;
             }
 
-            // eslint-disable-next-line no-loop-func
             this.#batch.push(() => {
                 enabled = mark.unitView.getEffectiveOpacity() > 0;
             });
@@ -201,7 +200,6 @@ export default class BufferedViewRenderingContext extends ViewRenderingContext {
                 // Render each facet
                 if (!coords.equals(previousCoords)) {
                     this.#batch.push(
-                        // eslint-disable-next-line no-loop-func
                         ifEnabled(() => {
                             // Suppress rendering if viewport is outside the clipRect
                             viewportVisible = mark.setViewport(

package/dist/src/view/resolutionPlanner.d.ts

@@ -0,0 +1,9 @@
+export function resolveViewResolutions(view: import("./unitView.js").default, type?: import("../spec/view.js").ResolutionTarget): void;
+export type ResolutionMember = {
+    view: import("./unitView.js").default;
+    channel: import("../spec/channel.js").Channel;
+    channelDef: import("../spec/channel.js").ChannelDefWithScale;
+    targetChannel: import("../spec/channel.js").ChannelWithScale;
+};
+export type ScaleResolutionMemberMap = Map<import("../scales/scaleResolution.js").default, ResolutionMember[]>;
+//# sourceMappingURL=resolutionPlanner.d.ts.map

package/dist/src/view/resolutionPlanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolutionPlanner.d.ts","sourceRoot":"","sources":["../../../src/view/resolutionPlanner.js"],"names":[],"mappings":"AA8RO,6CAHI,OAAO,eAAe,EAAE,OAAO,SAC/B,OAAO,iBAAiB,EAAE,gBAAgB,QAiBpD;;UAhSS,OAAO,eAAe,EAAE,OAAO;aAC/B,OAAO,oBAAoB,EAAE,OAAO;gBACpC,OAAO,oBAAoB,EAAE,mBAAmB;mBAChD,OAAO,oBAAoB,EAAE,gBAAgB;;uCAI1C,GAAG,CAAC,OAAO,8BAA8B,EAAE,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/src/view/resolutionPlanner.js

@@ -0,0 +1,302 @@
+import ScaleResolution from "../scales/scaleResolution.js";
+import AxisResolution from "../scales/axisResolution.js";
+import {
+    isPositionalChannel,
+    isChannelDefWithScale,
+    getPrimaryChannel,
+    isChannelWithScale,
+    isPrimaryPositionalChannel,
+    isValueDefWithCondition,
+} from "../encoder/encoder.js";
+
+/**
+ * @typedef {object} ResolutionMember
+ * @prop {import("./unitView.js").default} view
+ * @prop {import("../spec/channel.js").Channel} channel
+ * @prop {import("../spec/channel.js").ChannelDefWithScale} channelDef
+ * @prop {import("../spec/channel.js").ChannelWithScale} targetChannel
+ */
+
+/**
+ * @typedef {Map<import("../scales/scaleResolution.js").default, ResolutionMember[]>} ScaleResolutionMemberMap
+ */
+
+/**
+ * @param {unknown} channelDef
+ * @returns {import("../spec/channel.js").ChannelDefWithScale | undefined}
+ */
+const getChannelDefWithScale = (channelDef) => {
+    if (isChannelDefWithScale(channelDef)) {
+        return channelDef;
+    }
+
+    if (isValueDefWithCondition(channelDef)) {
+        const condition = channelDef.condition;
+        if (!Array.isArray(condition) && isChannelDefWithScale(condition)) {
+            return condition;
+        }
+    }
+
+    return undefined;
+};
+
+/**
+ * @param {import("./unitView.js").default} view
+ * @param {import("../spec/view.js").ResolutionTarget} type
+ * @param {import("../spec/channel.js").ChannelWithScale} targetChannel
+ * @returns {import("./unitView.js").default}
+ */
+const getResolutionView = (view, type, targetChannel) => {
+    let resolutionView = view;
+    while (
+        (resolutionView.getConfiguredOrDefaultResolution(targetChannel, type) ==
+            "forced" ||
+            (resolutionView.dataParent &&
+                ["shared", "excluded", "forced"].includes(
+                    resolutionView.dataParent.getConfiguredOrDefaultResolution(
+                        targetChannel,
+                        type
+                    )
+                ))) &&
+        resolutionView.getConfiguredOrDefaultResolution(targetChannel, type) !=
+            "excluded"
+    ) {
+        // @ts-ignore
+        resolutionView = resolutionView.dataParent;
+    }
+
+    return resolutionView;
+};
+
+/**
+ * @param {import("./unitView.js").default} ownerView
+ * @param {import("./unitView.js").default} resolutionView
+ * @param {import("../spec/channel.js").ChannelWithScale} targetChannel
+ * @returns {import("../scales/scaleResolution.js").default}
+ */
+const ensureScaleResolution = (ownerView, resolutionView, targetChannel) => {
+    if (!resolutionView.resolutions.scale[targetChannel]) {
+        const resolution = new ScaleResolution(targetChannel, resolutionView);
+        resolutionView.resolutions.scale[targetChannel] = resolution;
+
+        const updateRangeTexture = (
+            /** @type {import("../types/scaleResolutionApi.js").ScaleResolutionEvent} */ event
+        ) => {
+            ownerView.context.glHelper?.createRangeTexture(
+                event.scaleResolution,
+                true
+            );
+        };
+        resolution.addEventListener("range", updateRangeTexture);
+        resolution.addEventListener("domain", updateRangeTexture);
+        ownerView.registerDisposer(() => {
+            resolution.removeEventListener("range", updateRangeTexture);
+            resolution.removeEventListener("domain", updateRangeTexture);
+        });
+    }
+
+    return resolutionView.resolutions.scale[targetChannel];
+};
+
+/**
+ * @param {import("./unitView.js").default} view
+ * @param {import("../spec/view.js").ResolutionTarget} type
+ * @param {import("../spec/channel.js").Channel} channel
+ * @param {unknown} channelDef
+ * @returns {ResolutionMember | undefined}
+ */
+const getResolutionMember = (view, type, channel, channelDef) => {
+    const channelDefWithScale = getChannelDefWithScale(channelDef);
+    if (!channelDefWithScale) {
+        return undefined;
+    }
+
+    const targetChannel = getPrimaryChannel(
+        channelDefWithScale.resolutionChannel ?? channel
+    );
+    if (!isChannelWithScale(targetChannel)) {
+        return undefined;
+    }
+
+    if (type == "axis" && !isPositionalChannel(targetChannel)) {
+        return undefined;
+    }
+
+    return {
+        view: getResolutionView(view, type, targetChannel),
+        channel,
+        channelDef: channelDefWithScale,
+        targetChannel,
+    };
+};
+
+/**
+ * @param {import("./unitView.js").default} view
+ * @param {(channel: import("../spec/channel.js").Channel, channelDef: unknown) => void} callback
+ */
+const forEachEncodedChannel = (view, callback) => {
+    for (const [channel, channelDef] of Object.entries(view.mark.encoding)) {
+        if (!channelDef || Array.isArray(channelDef)) {
+            continue;
+        }
+
+        callback(
+            /** @type {import("../spec/channel.js").Channel} */ (channel),
+            channelDef
+        );
+    }
+};
+
+/**
+ * @param {import("./unitView.js").default} view
+ * @returns {ResolutionMember[]}
+ */
+const collectAxisResolutionMembers = (view) => {
+    /** @type {ResolutionMember[]} */
+    const axisMembers = [];
+    forEachEncodedChannel(view, (channel, channelDef) => {
+        const member = getResolutionMember(view, "axis", channel, channelDef);
+        if (member && isPositionalChannel(member.channel)) {
+            axisMembers.push(member);
+        }
+    });
+
+    return axisMembers;
+};
+
+/**
+ * @param {import("./unitView.js").default} view
+ * @returns {ScaleResolutionMemberMap}
+ */
+const collectScaleResolutionMembers = (view) => {
+    /** @type {ScaleResolutionMemberMap} */
+    const scaleMembersByResolution = new Map();
+
+    forEachEncodedChannel(view, (channel, channelDef) => {
+        const member = getResolutionMember(view, "scale", channel, channelDef);
+        if (!member) {
+            return;
+        }
+
+        const resolution = ensureScaleResolution(
+            view,
+            member.view,
+            member.targetChannel
+        );
+        const members = scaleMembersByResolution.get(resolution);
+        if (members) {
+            members.push(member);
+        } else {
+            scaleMembersByResolution.set(resolution, [member]);
+        }
+    });
+
+    return scaleMembersByResolution;
+};
+
+/**
+ * @param {import("./unitView.js").default} view
+ * @param {ResolutionMember[]} axisMembers
+ */
+const registerAxisResolutionMembers = (view, axisMembers) => {
+    for (const {
+        view: resolutionView,
+        channel,
+        channelDef,
+        targetChannel,
+    } of axisMembers) {
+        if (
+            !isPositionalChannel(channel) ||
+            !isPrimaryPositionalChannel(targetChannel)
+        ) {
+            continue;
+        }
+
+        if (!resolutionView.resolutions.axis[targetChannel]) {
+            resolutionView.resolutions.axis[targetChannel] = new AxisResolution(
+                targetChannel
+            );
+        }
+        const resolution = resolutionView.resolutions.axis[targetChannel];
+        const unregister = resolution.registerMember({
+            view,
+            channel,
+            channelDef,
+        });
+        view.registerDisposer(() => {
+            if (
+                unregister() &&
+                resolutionView.resolutions.axis[targetChannel] === resolution
+            ) {
+                delete resolutionView.resolutions.axis[targetChannel];
+            }
+        });
+    }
+};
+
+/**
+ * @param {import("./unitView.js").default} view
+ * @param {ScaleResolutionMemberMap} scaleMembersByResolution
+ */
+const registerScaleResolutionMembers = (view, scaleMembersByResolution) => {
+    ScaleResolution.registerInBatch(scaleMembersByResolution.keys(), () => {
+        for (const [resolution, members] of scaleMembersByResolution) {
+            for (const {
+                view: resolutionView,
+                channel,
+                channelDef,
+                targetChannel,
+            } of members) {
+                const scaleChannel =
+                    /** @type {import("../spec/channel.js").ChannelWithScale} */ (
+                        targetChannel
+                    );
+
+                const contributesToDomain = !view.isDomainInert();
+
+                const unregister = resolution.registerMember({
+                    view,
+                    channel:
+                        /** @type {import("../spec/channel.js").ChannelWithScale} */ (
+                            channel
+                        ),
+                    channelDef,
+                    contributesToDomain,
+                });
+                view.registerDisposer(() => {
+                    if (
+                        unregister() &&
+                        resolutionView.resolutions.scale[scaleChannel] ===
+                            resolution
+                    ) {
+                        resolution.dispose();
+                        delete resolutionView.resolutions.scale[scaleChannel];
+                    }
+                });
+            }
+        }
+    });
+};
+
+/**
+ * Resolves scale and axis members for a view.
+ *
+ * @param {import("./unitView.js").default} view
+ * @param {import("../spec/view.js").ResolutionTarget} [type]
+ */
+export const resolveViewResolutions = (view, type) => {
+    if (!type) {
+        resolveViewResolutions(view, "scale");
+        resolveViewResolutions(view, "axis");
+        return;
+    }
+
+    if (type == "axis") {
+        registerAxisResolutionMembers(view, collectAxisResolutionMembers(view));
+    } else {
+        registerScaleResolutionMembers(
+            view,
+            collectScaleResolutionMembers(view)
+        );
+    }
+};

package/dist/src/view/testUtils.d.ts

@@ -3,23 +3,37 @@
  * @returns
  */
 export function createTestViewContext(viewFactoryOptions?: import("./viewFactory.js").ViewFactoryOptions): import("../types/viewContext.js").default;
-export function create<V extends import("./view.js").default>(spec: ViewSpec, viewClass: {
+/**
+ * @param {import("./viewFactory.js").ViewFactoryOptions} [viewFactoryOptions]
+ * @returns {BroadcastingViewContext}
+ */
+export function createBroadcastingTestViewContext(viewFactoryOptions?: import("./viewFactory.js").ViewFactoryOptions): BroadcastingViewContext;
+export function create<V extends import("./view.js").default>(spec: RootSpec, viewClass: {
     new (...args: any[]): V;
 }, ViewFactoryOptions?: import("./viewFactory.js").ViewFactoryOptions): Promise<V>;
-export function createAndInitialize<V extends import("./view.js").default>(spec: ViewSpec, viewClass: {
+export function createAndInitialize<V extends import("./view.js").default>(spec: RootSpec, viewClass: {
     new (...args: any[]): V;
 }, context?: ViewContext, options?: {
     noData: boolean;
     implicitRoot: boolean;
 }): Promise<V>;
+export { createHeadlessEngine };
 /**
  * Utils for Jest tests
  * TODO: Find a better place and convention
  */
-export type ViewSpec = import("../spec/view.js").ViewSpec;
+export type RootSpec = import("../spec/root.js").RootSpec;
 /**
  * Utils for Jest tests
  * TODO: Find a better place and convention
  */
 export type ViewContext = import("../types/viewContext.js").default;
+/**
+ * Utils for Jest tests
+ * TODO: Find a better place and convention
+ */
+export type BroadcastingViewContext = ViewContext & {
+    emitBroadcast: (root: import("./view.js").default, type: import("../genomeSpy.js").BroadcastEventType, payload?: any) => void;
+};
+import { createHeadlessEngine } from "../genomeSpy/headlessBootstrap.js";
 //# sourceMappingURL=testUtils.d.ts.map

package/dist/src/view/testUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testUtils.d.ts","sourceRoot":"","sources":["../../../src/view/testUtils.js"],"names":[],"mappings":"AAoBA;;;GAGG;AACH,2DAHW,OAAO,kBAAkB,EAAE,kBAAkB,6CAoEvD;AAGS,uBAAC,CAAC,SAAS,OAAO,WAAW,EAAE,OAAO,QAAQ,QAAQ,aAAa;IAAE,KAAI,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;CAAE,uBAAuB,OAAO,kBAAkB,EAAE,kBAAkB,GAAK,OAAO,CAAC,CAAC,CAAC,CAAA;AAgBhL,oCAAC,CAAC,SAAS,OAAO,WAAW,EAAE,OAAO,QAAQ,QAAQ,aAAa;IAAE,KAAI,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;CAAE,YAAY,WAAW,YAAY;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAC,GAAK,OAAO,CAAC,CAAC,CAAC,CAAA;;;;;uBAxGpL,OAAO,iBAAiB,EAAE,QAAQ;;;;;0BAClC,OAAO,yBAAyB,EAAE,OAAO"}
+{"version":3,"file":"testUtils.d.ts","sourceRoot":"","sources":["../../../src/view/testUtils.js"],"names":[],"mappings":"AA4BA;;;GAGG;AACH,2DAHW,OAAO,kBAAkB,EAAE,kBAAkB,6CAOvD;AAED;;;GAGG;AACH,uEAHW,OAAO,kBAAkB,EAAE,kBAAkB,GAC3C,uBAAuB,CAmCnC;AAGS,uBAAC,CAAC,SAAS,OAAO,WAAW,EAAE,OAAO,QAAQ,QAAQ,aAAa;IAAE,KAAI,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;CAAE,uBAAuB,OAAO,kBAAkB,EAAE,kBAAkB,GAAK,OAAO,CAAC,CAAC,CAAC,CAAA;AAqBhL,oCAAC,CAAC,SAAS,OAAO,WAAW,EAAE,OAAO,QAAQ,QAAQ,aAAa;IAAE,KAAI,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;CAAE,YAAY,WAAW,YAAY;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAC,GAAK,OAAO,CAAC,CAAC,CAAC,CAAA;;;;;;uBA/FpL,OAAO,iBAAiB,EAAE,QAAQ;;;;;0BAClC,OAAO,yBAAyB,EAAE,OAAO;;;;;sCACzC,WAAW,GAAG;IACtB,aAAa,EAAE,CACb,IAAI,EAAE,OAAO,WAAW,EAAE,OAAO,EACjC,IAAI,EAAE,OAAO,iBAAiB,EAAE,kBAAkB,EAClD,OAAO,CAAC,EAAE,GAAG,KACV,IAAI,CAAA;CACV;qCAcG,mCAAmC"}