@genome-spy/core 0.71.0 → 0.73.0

package/dist/src/genomeSpy/interactionController.js

@@ -82,11 +82,29 @@ export default class InteractionController {
         return this.#currentHover;
     }
 
-    registerMouseEvents() {
+    registerInteractionEvents() {
         const canvas = this.#glHelper.canvas;
 
         let lastWheelEvent = performance.now();
         let longPressTriggered = false;
+        /** @type {{ pointerCount: 1 | 2, centerX: number, centerY: number, distance: number } | undefined} */
+        let previousTouchGesture;
+
+        /**
+         * @param {Point} point
+         * @param {import("../utils/interactionEvent.js").InteractionUiEvent} uiEvent
+         * @returns {InteractionEvent}
+         */
+        const dispatchInteractionEvent = (point, uiEvent) => {
+            const interactionEvent = new InteractionEvent(point, uiEvent);
+            this.#viewRoot.propagateInteractionEvent(interactionEvent);
+
+            if (!this.#tooltipUpdateRequested) {
+                this.#tooltip.clear();
+            }
+
+            return interactionEvent;
+        };
 
         /** @param {Event} event */
         const listener = (event) => {
@@ -117,13 +135,7 @@ export default class InteractionController {
                  * @param {MouseEvent} dispatchedEvent
                  */
                 const dispatchEvent = (dispatchedEvent) => {
-                    this.#viewRoot.propagateInteractionEvent(
-                        new InteractionEvent(point, dispatchedEvent)
-                    );
-
-                    if (!this.#tooltipUpdateRequested) {
-                        this.#tooltip.clear();
-                    }
+                    dispatchInteractionEvent(point, dispatchedEvent);
                 };
 
                 if (event.type != "wheel") {
@@ -156,26 +168,41 @@ export default class InteractionController {
 
                         this.#wheelInertia.cancel();
                     } else {
-                        // Vertical wheeling zooms.
-                        // We use inertia to generate fake wheel events for smoother zooming
-
-                        const template = makeEventTemplate(wheelEvent);
-
-                        this.#wheelInertia.setMomentum(
-                            wheelEvent.deltaY * (wheelEvent.deltaMode ? 80 : 1),
-                            (delta) => {
-                                const e = new WheelEvent("wheel", {
-                                    ...template,
-                                    deltaMode: 0,
-                                    deltaX: 0,
-                                    deltaY: delta,
-                                });
-                                dispatchEvent(e);
-                            }
-                        );
-
-                        wheelEvent.preventDefault();
-                        return;
+                        // We must decide on the native wheel event whether to
+                        // call preventDefault() (to block page scrolling).
+                        // This probe asks the pointed view hierarchy to claim
+                        // wheel ownership without running real wheel side
+                        // effects first. Inertia is layered on top of that
+                        // decision and is not the reason for the probe.
+                        const probeEvent = dispatchInteractionEvent(point, {
+                            type: "wheelclaimprobe",
+                        });
+
+                        if (probeEvent.wheelClaimed) {
+                            // Vertical wheeling zooms.
+                            // We use inertia to generate fake wheel events for smoother zooming
+
+                            const template = makeEventTemplate(wheelEvent);
+
+                            this.#wheelInertia.setMomentum(
+                                wheelEvent.deltaY *
+                                    (wheelEvent.deltaMode ? 80 : 1),
+                                (delta) => {
+                                    const e = new WheelEvent("wheel", {
+                                        ...template,
+                                        deltaMode: 0,
+                                        deltaX: 0,
+                                        deltaY: delta,
+                                    });
+                                    dispatchEvent(e);
+                                }
+                            );
+
+                            wheelEvent.preventDefault();
+                            return;
+                        } else {
+                            this.#wheelInertia.cancel();
+                        }
                     }
                 }
 
@@ -223,11 +250,168 @@ export default class InteractionController {
             "wheel",
             "click",
             "mousemove",
-            "gesturechange",
             "contextmenu",
             "dblclick",
         ].forEach((type) => canvas.addEventListener(type, listener));
 
+        /**
+         * @param {number} clientX
+         * @param {number} clientY
+         */
+        const toCanvasPoint = (clientX, clientY) => {
+            const rect = canvas.getBoundingClientRect();
+            return new Point(
+                clientX - rect.left - canvas.clientLeft,
+                clientY - rect.top - canvas.clientTop
+            );
+        };
+
+        /**
+         * @param {TouchList} touches
+         */
+        const readTouchGesture = (touches) => {
+            if (touches.length <= 0) {
+                return;
+            }
+
+            const first = touches[0];
+
+            if (touches.length === 1) {
+                return {
+                    pointerCount: /** @type {1} */ (1),
+                    centerX: first.clientX,
+                    centerY: first.clientY,
+                    distance: 0,
+                };
+            }
+
+            const second = touches[1];
+            return {
+                pointerCount: /** @type {2} */ (2),
+                centerX: (first.clientX + second.clientX) / 2,
+                centerY: (first.clientY + second.clientY) / 2,
+                distance: getClientDistance(first, second),
+            };
+        };
+
+        /**
+         * @param {number} x
+         * @param {number} y
+         * @param {"move" | "end"} phase
+         * @param {1 | 2} pointerCount
+         * @param {number} xDelta
+         * @param {number} yDelta
+         * @param {number} zDelta
+         */
+        const dispatchTouchGestureEvent = (
+            x,
+            y,
+            phase,
+            pointerCount,
+            xDelta,
+            yDelta,
+            zDelta
+        ) => {
+            const point = toCanvasPoint(x, y);
+            dispatchInteractionEvent(point, {
+                type: "touchgesture",
+                phase,
+                pointerCount,
+                xDelta,
+                yDelta,
+                zDelta,
+            });
+        };
+
+        /**
+         * @param {TouchEvent} touchEvent
+         */
+        const handleTouchStartOrMove = (touchEvent) => {
+            touchEvent.preventDefault();
+            this.#wheelInertia.cancel();
+            this.#tooltipUpdateRequested = false;
+
+            const currentGesture = readTouchGesture(touchEvent.touches);
+            if (!currentGesture) {
+                previousTouchGesture = undefined;
+                return;
+            }
+
+            if (
+                !previousTouchGesture ||
+                previousTouchGesture.pointerCount !==
+                    currentGesture.pointerCount
+            ) {
+                previousTouchGesture = currentGesture;
+                return;
+            }
+
+            const xDelta =
+                currentGesture.centerX - previousTouchGesture.centerX;
+            const yDelta =
+                currentGesture.centerY - previousTouchGesture.centerY;
+            const zDelta =
+                currentGesture.pointerCount === 2
+                    ? pinchDistanceToZoomDelta(
+                          previousTouchGesture.distance,
+                          currentGesture.distance
+                      )
+                    : 0;
+
+            if (
+                (xDelta !== 0 || yDelta !== 0 || zDelta !== 0) &&
+                Number.isFinite(xDelta) &&
+                Number.isFinite(yDelta) &&
+                Number.isFinite(zDelta)
+            ) {
+                dispatchTouchGestureEvent(
+                    previousTouchGesture.centerX,
+                    previousTouchGesture.centerY,
+                    "move",
+                    currentGesture.pointerCount,
+                    xDelta,
+                    yDelta,
+                    zDelta
+                );
+            }
+
+            previousTouchGesture = currentGesture;
+        };
+
+        /**
+         * @param {TouchEvent} touchEvent
+         */
+        const handleTouchEndOrCancel = (touchEvent) => {
+            touchEvent.preventDefault();
+            this.#tooltipUpdateRequested = false;
+            if (previousTouchGesture && touchEvent.touches.length === 0) {
+                dispatchTouchGestureEvent(
+                    previousTouchGesture.centerX,
+                    previousTouchGesture.centerY,
+                    "end",
+                    previousTouchGesture.pointerCount,
+                    0,
+                    0,
+                    0
+                );
+            }
+
+            previousTouchGesture = readTouchGesture(touchEvent.touches);
+        };
+
+        canvas.addEventListener("touchstart", handleTouchStartOrMove, {
+            passive: false,
+        });
+        canvas.addEventListener("touchmove", handleTouchStartOrMove, {
+            passive: false,
+        });
+        canvas.addEventListener("touchend", handleTouchEndOrCancel, {
+            passive: false,
+        });
+        canvas.addEventListener("touchcancel", handleTouchEndOrCancel, {
+            passive: false,
+        });
+
         canvas.addEventListener("mousedown", (/** @type {MouseEvent} */ e) => {
             this.#mouseDownCoords = Point.fromMouseEvent(e);
             if (this.#tooltip.sticky) {
@@ -375,3 +559,34 @@ export default class InteractionController {
         }
     }
 }
+
+/**
+ * @typedef {{clientX: number, clientY: number}} ClientPointLike
+ */
+
+/**
+ * Returns euclidean distance between two client-space points.
+ *
+ * @param {ClientPointLike} a
+ * @param {ClientPointLike} b
+ */
+function getClientDistance(a, b) {
+    const dx = b.clientX - a.clientX;
+    const dy = b.clientY - a.clientY;
+    return Math.hypot(dx, dy);
+}
+
+/**
+ * Converts a pinch distance ratio to a zDelta used by interactionToZoom:
+ * scaleFactor = 2 ** zDelta.
+ *
+ * @param {number} previousDistance
+ * @param {number} currentDistance
+ */
+function pinchDistanceToZoomDelta(previousDistance, currentDistance) {
+    if (previousDistance <= 0 || currentDistance <= 0) {
+        return 0;
+    }
+
+    return Math.log2(previousDistance / currentDistance);
+}

package/dist/src/genomeSpy/renderCoordinator.js

@@ -70,7 +70,7 @@ export default class RenderCoordinator {
         const commonOptions = {
             webGLHelper: this.#glHelper,
             canvasSize,
-            devicePixelRatio: window.devicePixelRatio ?? 1,
+            devicePixelRatio: this.#glHelper.getDevicePixelRatio(canvasSize),
         };
 
         this.#renderingContext = new BufferedViewRenderingContext(

package/dist/src/genomeSpy.d.ts

@@ -77,7 +77,13 @@ export default class GenomeSpy {
      */
     launch(): Promise<boolean>;
     initializeVisibleViewData(): Promise<void>;
-    registerMouseEvents(): void;
+    /**
+     * Waits until lazy sources under the root view have loaded data for the
+     * current visible positional domain.
+     *
+     * @param {AbortSignal} [signal]
+     */
+    awaitVisibleLazyData(signal?: AbortSignal): Promise<void>;
     /**
      * This method should be called in a mouseMove handler. If not called, the
      * tooltip will be hidden.
@@ -98,8 +104,12 @@ export default class GenomeSpy {
      */
     exportCanvas(logicalWidth?: number, logicalHeight?: number, devicePixelRatio?: number, clearColor?: string): string;
     getLogicalCanvasSize(): {
-        width: any;
-        height: any;
+        width: number;
+        height: number;
+    };
+    getRenderedBounds(): {
+        width: number | undefined;
+        height: number | undefined;
     };
     computeLayout(): void;
     renderAll(): void;

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

@@ -1 +1 @@
-{"version":3,"file":"genomeSpy.d.ts","sourceRoot":"","sources":["../../src/genomeSpy.js"],"names":[],"mappings":"AA+CA;IAoBI;;;;;OAKG;IAEH;;;;;OAKG;IACH,uBAJW,WAAW,qDAEX,OAAO,qBAAqB,EAAE,YAAY,EA0CpD;IAvCG,uBAA0B;IAC1B,oDAAsB;IAItB,sCAAsC;IACtC,wCAAgB;IAEhB,yBAAoC;IAEpC,4CAA4C;IAC5C,oBADW,CAAC,CAAS,IAAM,EAAN,MAAM,KAAE,MAAM,EAAE,CAAC,EAAE,CACZ;IAE5B,mBAAoD;IAEpD,0BAA0B;IAC1B,aADW,WAAW,CACM;IAE5B;;;;;OAKG;IACH,yBAFU,CAAC,IAAI,qEAAM,KAAK,OAAO,CAE8B;IAE/D,oFAAoF;IACpF,iBADW,MAAM,CAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,cAAc,CAAC,CAK9E;IAED,mBAAmB;IACnB,8EAAyB;IAIzB,YAAkC;IAatC;;;OAGG;IACH,oCAFW,CAAC,IAAI,EAAE,MAAM,KAAK,GAAG,EAAE,QAIjC;IAED;;OAEG;IACH,+BAFW,MAAM,YAShB;IAED;;;;OAIG;IACH,sBAHW,MAAM,QACN,GAAG,EAAE,QAYf;IAED;;;OAGG;IACH,uBAHW,MAAM,YACN,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,QAI9B;IAED;;;OAGG;IACH,0BAHW,MAAM,YACN,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,QAI9B;IAED;;;;;OAKG;IACH,gBAHW,kBAAkB,YAClB,GAAG,QAMb;IA8DG,iDAAsB;IAQ1B;;OAEG;IACH,gBAqBC;IA+KD;;;OAGG;IACH,UAFa,OAAO,CAAC,OAAO,CAAC,CAyC5B;IAED,2CAiBC;IAED,4BAEC;IAED;;;;;;;OAOG;IACH,cAFa,CAAC,SAFH,CAAC,cACD,CAAS,IAAC,EAAD,CAAC,KAAE,OAAO,CAAC,MAAM,GAAG,WAAW,GAAG,OAAO,KAAK,EAAE,cAAc,CAAC,QAKlF;IAED;;;;;;;;OAQG;IACH,4BANW,MAAM,kBACN,MAAM,qBACN,MAAM,eACN,MAAM,UAuBhB;IAED;;;MAEC;IAED,sBAEC;IAED,kBAEC;IAED,iCAEC;IAED,oEAYC;IAED,uFAWC;;CACJ;;;;iCA/jBY,eAAe,GAAG,QAAQ,GAAG,gBAAgB,GAAG,kBAAkB;4BAbnC,uBAAuB;qBAR9C,qBAAqB;wBAElB,yBAAyB;qBAL5B,oBAAoB"}
+{"version":3,"file":"genomeSpy.d.ts","sourceRoot":"","sources":["../../src/genomeSpy.js"],"names":[],"mappings":"AAyDA;IAoBI;;;;;OAKG;IAEH;;;;;OAKG;IACH,uBAJW,WAAW,qDAEX,OAAO,qBAAqB,EAAE,YAAY,EA0CpD;IAvCG,uBAA0B;IAC1B,oDAAsB;IAItB,sCAAsC;IACtC,wCAAgB;IAEhB,yBAAoC;IAEpC,4CAA4C;IAC5C,oBADW,CAAC,CAAS,IAAM,EAAN,MAAM,KAAE,MAAM,EAAE,CAAC,EAAE,CACZ;IAE5B,mBAAoD;IAEpD,0BAA0B;IAC1B,aADW,WAAW,CACM;IAE5B;;;;;OAKG;IACH,yBAFU,CAAC,IAAI,qEAAM,KAAK,OAAO,CAE8B;IAE/D,oFAAoF;IACpF,iBADW,MAAM,CAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,cAAc,CAAC,CAK9E;IAED,mBAAmB;IACnB,8EAAyB;IAIzB,YAAkC;IAatC;;;OAGG;IACH,oCAFW,CAAC,IAAI,EAAE,MAAM,KAAK,GAAG,EAAE,QAIjC;IAED;;OAEG;IACH,+BAFW,MAAM,YAShB;IAED;;;;OAIG;IACH,sBAHW,MAAM,QACN,GAAG,EAAE,QAYf;IAED;;;OAGG;IACH,uBAHW,MAAM,YACN,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,QAI9B;IAED;;;OAGG;IACH,0BAHW,MAAM,YACN,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,QAI9B;IAED;;;;;OAKG;IACH,gBAHW,kBAAkB,YAClB,GAAG,QAMb;IAgEG,iDAAsB;IAQ1B;;OAEG;IACH,gBAqBC;IA0LD;;;OAGG;IACH,UAFa,OAAO,CAAC,OAAO,CAAC,CAyC5B;IAED,2CAiBC;IAED;;;;;OAKG;IACH,8BAFW,WAAW,iBAgBrB;IAED;;;;;;;OAOG;IACH,cAFa,CAAC,SAFH,CAAC,cACD,CAAS,IAAC,EAAD,CAAC,KAAE,OAAO,CAAC,MAAM,GAAG,WAAW,GAAG,OAAO,KAAK,EAAE,cAAc,CAAC,QAKlF;IAED;;;;;;;;OAQG;IACH,4BANW,MAAM,kBACN,MAAM,qBACN,MAAM,eACN,MAAM,UAuBhB;IAED;;;MAEC;IAED;eACwB,MAAM,GAAG,SAAS;gBAAU,MAAM,GAAG,SAAS;MAcrE;IAED,sBAEC;IAED,kBAEC;IAED,iCAEC;IAED,oEAYC;IAED,uFAWC;;CACJ;;;;iCAlnBY,eAAe,GAAG,QAAQ,GAAG,gBAAgB,GAAG,kBAAkB;4BApBnC,uBAAuB;qBAR9C,qBAAqB;wBAElB,yBAAyB;qBAL5B,oBAAoB"}

package/dist/src/genomeSpy.js

@@ -37,6 +37,13 @@ import {
 } from "./genomeSpy/viewHierarchyConfig.js";
 import { exportCanvas } from "./genomeSpy/canvasExport.js";
 import { validateSelectorConstraints } from "./view/viewSelectors.js";
+import parquet from "./data/formats/parquet.js";
+import bed from "./data/formats/bed.js";
+import bedpe from "./data/formats/bedpe.js";
+import SingleAxisWindowedSource from "./data/sources/lazy/singleAxisWindowedSource.js";
+import { ensureAssembliesForView } from "./genome/assemblyPreflight.js";
+import { resolveRootGenomeConfig } from "./genome/rootGenomeConfig.js";
+import { awaitSubtreeLazyReady } from "./view/dataReadiness.js";
 
 /**
  * Events that are broadcasted to all views.
@@ -44,6 +51,9 @@ import { validateSelectorConstraints } from "./view/viewSelectors.js";
  */
 
 vegaFormats("fasta", fasta);
+vegaFormats("parquet", parquet);
+vegaFormats("bed", bed);
+vegaFormats("bedpe", bedpe);
 
 export default class GenomeSpy {
     /** @type {(() => void)[]} */
@@ -196,6 +206,8 @@ export default class GenomeSpy {
     }
 
     #setupDpr() {
+        this.dpr = this.#glHelper.getDevicePixelRatio();
+
         const dprSetter = this.viewRoot.paramRuntime.allocateSetter(
             "devicePixelRatio",
             this.dpr
@@ -203,7 +215,7 @@ export default class GenomeSpy {
 
         const resizeCallback = () => {
             this.#glHelper.invalidateSize();
-            this.dpr = window.devicePixelRatio;
+            this.dpr = this.#glHelper.getDevicePixelRatio();
             dprSetter(this.dpr);
             this.computeLayout();
             // Render immediately, without RAF
@@ -303,9 +315,15 @@ export default class GenomeSpy {
     }
 
     async #initializeGenomeStore() {
-        if (this.spec.genome) {
-            this.genomeStore = new GenomeStore(this.spec.baseUrl);
-            await this.genomeStore.initialize(this.spec.genome);
+        this.genomeStore = new GenomeStore(this.spec.baseUrl);
+
+        const { genomesByName, defaultAssembly, deprecationWarning } =
+            resolveRootGenomeConfig(this.spec);
+        this.genomeStore.configureGenomes(genomesByName, defaultAssembly);
+
+        if (deprecationWarning) {
+            // eslint-disable-next-line no-console
+            console.warn(deprecationWarning);
         }
     }
 
@@ -396,6 +414,11 @@ export default class GenomeSpy {
             VIEW_ROOT_NAME
         );
 
+        // Reminder: assemblies must be ensured after view creation (imports and
+        // inheritance resolved), but before any code path that may touch scales
+        // (e.g. step-based sizes, dynamic opacity, encoder initialization).
+        await ensureAssembliesForView(this.viewRoot, this.genomeStore);
+
         this.#loadingStatusRegistry.set(this.viewRoot, "loading");
 
         this.#canvasWrapper.style.flexGrow =
@@ -473,7 +496,7 @@ export default class GenomeSpy {
 
             await this.#prepareViewsAndData();
 
-            this.registerMouseEvents();
+            this.#interactionController.registerInteractionEvents();
 
             this.computeLayout();
             this.animator.requestRender();
@@ -526,8 +549,26 @@ export default class GenomeSpy {
         this.animator.requestRender();
     }
 
-    registerMouseEvents() {
-        this.#interactionController.registerMouseEvents();
+    /**
+     * Waits until lazy sources under the root view have loaded data for the
+     * current visible positional domain.
+     *
+     * @param {AbortSignal} [signal]
+     */
+    async awaitVisibleLazyData(signal) {
+        if (!this.viewRoot) {
+            return;
+        }
+
+        await awaitSubtreeLazyReady(
+            this.viewRoot.context,
+            this.viewRoot,
+            undefined,
+            signal,
+            (view) =>
+                view.isConfiguredVisible() &&
+                hasWindowedLazyDataSource(view)
+        );
     }
 
     /**
@@ -577,6 +618,23 @@ export default class GenomeSpy {
         return this.#glHelper.getLogicalCanvasSize();
     }
 
+    getRenderedBounds() {
+        /** @type {{ width: number | undefined, height: number | undefined }} */
+        const bounds = {
+            width: undefined,
+            height: undefined,
+        };
+
+        this.viewRoot.visit((view) => {
+            for (const coords of view.facetCoords.values()) {
+                bounds.width = Math.max(bounds.width ?? 0, coords.x2);
+                bounds.height = Math.max(bounds.height ?? 0, coords.y2);
+            }
+        });
+
+        return bounds;
+    }
+
     computeLayout() {
         this.#renderCoordinator.computeLayout();
     }
@@ -616,3 +674,21 @@ export default class GenomeSpy {
         return resolutions;
     }
 }
+
+/**
+ * @param {View} view
+ */
+function hasWindowedLazyDataSource(view) {
+    /** @type {View | null} */
+    let current = view;
+
+    while (current) {
+        const dataSource = current.flowHandle?.dataSource;
+        if (dataSource) {
+            return dataSource instanceof SingleAxisWindowedSource;
+        }
+        current = current.dataParent;
+    }
+
+    return false;
+}

package/dist/src/gl/canvasSizeHelper.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Handles logical/physical canvas size calculations and optional
+ * device-pixel-content-box observation.
+ */
+export default class CanvasSizeHelper {
+    /**
+     * @param {HTMLElement} container
+     * @param {HTMLCanvasElement} canvas
+     * @param {() => {width: number, height: number}} sizeSource
+     * @param {() => void} [onPhysicalSizeChange]
+     */
+    constructor(container: HTMLElement, canvas: HTMLCanvasElement, sizeSource: () => {
+        width: number;
+        height: number;
+    }, onPhysicalSizeChange?: () => void);
+    _container: HTMLElement;
+    _canvas: HTMLCanvasElement;
+    _sizeSource: () => {
+        width: number;
+        height: number;
+    };
+    _onPhysicalSizeChange: () => void;
+    /**
+     * @type {{ width: number, height: number } | undefined}
+     */
+    _logicalCanvasSize: {
+        width: number;
+        height: number;
+    } | undefined;
+    /**
+     * @type {{ width: number, height: number } | undefined}
+     */
+    _devicePixelContentBoxSize: {
+        width: number;
+        height: number;
+    } | undefined;
+    /**
+     * @type {ResizeObserver | undefined}
+     */
+    _devicePixelContentBoxObserver: ResizeObserver | undefined;
+    invalidate(): void;
+    finalize(): void;
+    /**
+     * Returns the canvas size in true display pixels
+     *
+     * @param {{ width: number, height: number }} [logicalSize]
+     */
+    getPhysicalCanvasSize(logicalSize?: {
+        width: number;
+        height: number;
+    }): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Returns the ratio between true display pixels and logical pixels.
+     *
+     * @param {{ width: number, height: number }} [logicalSize]
+     */
+    getDevicePixelRatio(logicalSize?: {
+        width: number;
+        height: number;
+    }): number;
+    /**
+     * Returns the size of the canvas canvas container size in logical pixels,
+     * without devicePixelRatio correction.
+     */
+    getLogicalCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    _observeDevicePixelContentBox(): void;
+}
+//# sourceMappingURL=canvasSizeHelper.d.ts.map

package/dist/src/gl/canvasSizeHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvasSizeHelper.d.ts","sourceRoot":"","sources":["../../../src/gl/canvasSizeHelper.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH;IACI;;;;;OAKG;IACH,uBALW,WAAW,UACX,iBAAiB,cACjB,MAAM;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,yBACrC,MAAM,IAAI,EAwBpB;IArBG,wBAA2B;IAC3B,2BAAqB;IACrB,mBANa;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAMf;IAC7B,6BANa,IAAI,CAM8C;IAE/D;;OAEG;IACH,oBAFU;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAEpB;IAEnC;;OAEG;IACH,4BAFU;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAEZ;IAE3C;;OAEG;IACH,gCAFU,cAAc,GAAG,SAAS,CAEW;IAKnD,mBAGC;IAED,iBAIC;IAED;;;;OAIG;IACH,oCAFW;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;eA1BrB,MAAM;gBAAU,MAAM;MA0C5C;IAED;;;;OAIG;IACH,kCAFW;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,UA2B3C;IAED;;;OAGG;IACH;eArFuB,MAAM;gBAAU,MAAM;MA8H5C;IAED,sCAuDC;CACJ"}