@genome-spy/core 0.74.0 → 0.76.0

package/dist/src/scales/domainPlanner.js

@@ -11,6 +11,7 @@ import {
     resolveIntervalSelectionBinding,
 } from "./selectionDomainUtils.js";
 import createDomain from "../utils/domainArray.js";
+import { isExprRef } from "../paramRuntime/paramUtils.js";
 import { getAccessorDomainKey, isScaleAccessor } from "../encoder/accessor.js";
 import { getEncoderAccessors, getPrimaryChannel } from "../encoder/encoder.js";
 import {
@@ -18,12 +19,45 @@ import {
     isChromosomalLocusInterval,
 } from "../genome/genome.js";
 
+/*
+ * Domain planning decides what domain a shared scale should use before the
+ * scale instance is configured.
+ *
+ * "Planning" means collecting the participating members, separating literal
+ * configured domains from selection-driven domains, validating that the shared
+ * scale is not asked to mix incompatible sources, and producing the final union
+ * that will be applied to the scale.
+ */
+
 /**
  * @typedef {import("../utils/domainArray.js").DomainArray} DomainArray
  * @typedef {import("../spec/scale.js").ComplexDomain} ComplexDomain
  * @typedef {import("../spec/scale.js").ScalarDomain} ScalarDomain
  * @typedef {import("../spec/scale.js").SelectionDomainRef} SelectionDomainRef
+ * @typedef {import("../spec/parameter.js").ExprRef} ExprRef
  * @typedef {import("./scaleResolution.js").ScaleResolutionMember} ScaleResolutionMember
+ * @typedef {() => Set<ScaleResolutionMember>} ScaleMembersGetter
+ * @typedef {(interval: ScalarDomain | ComplexDomain) => number[]} FromComplexInterval
+ * @typedef {(assembly: import("../spec/scale.js").Scale["assembly"] | undefined) => number[]} GetLocusExtent
+ * @typedef {{
+ *   domains: DomainArray[],
+ *   selectionRef: SelectionDomainLinkInfo | undefined,
+ *   selectionRuntime: any,
+ *   selectionDescription: string | undefined,
+ *   hasLiteralDomain: boolean,
+ * }} ConfiguredDomainResolutionState
+ * @typedef {{
+ *   kind: "literal",
+ *   domain: DomainArray,
+ * } | {
+ *   kind: "selection",
+ *   domain: DomainArray | undefined,
+ *   description: string,
+ *   param: string,
+ *   encoding: "x" | "y",
+ *   hasInitial: boolean,
+ *   runtime: any,
+ * }} ConfiguredDomainMemberResolution
  * @typedef {{
  *   param: string,
  *   encoding: "x" | "y",
@@ -33,22 +67,22 @@ import {
  */
 
 export default class DomainPlanner {
-    /** @type {() => Set<ScaleResolutionMember>} */
-    #getMembers;
+    /** @type {ScaleMembersGetter} */
+    #getActiveMembers;
 
-    /** @type {() => Set<ScaleResolutionMember>} */
+    /** @type {ScaleMembersGetter} */
     #getAllMembers;
 
-    /** @type {() => Set<ScaleResolutionMember>} */
+    /** @type {ScaleMembersGetter} */
     #getDataMembers;
 
     /** @type {() => import("../spec/channel.js").Type} */
     #getType;
 
-    /** @type {(assembly: import("../spec/scale.js").Scale["assembly"] | undefined) => number[]} */
+    /** @type {GetLocusExtent} */
     #getLocusExtent;
 
-    /** @type {(interval: ScalarDomain | ComplexDomain) => number[]} */
+    /** @type {FromComplexInterval} */
     #fromComplexInterval;
 
     /** @type {any[]} */
@@ -67,24 +101,24 @@ export default class DomainPlanner {
 
     /**
      * @param {object} options
-     * @param {() => Set<ScaleResolutionMember>} options.getMembers
-     * @param {() => Set<ScaleResolutionMember>} [options.getAllMembers]
-     * @param {() => Set<ScaleResolutionMember>} [options.getDataMembers]
+     * @param {ScaleMembersGetter} options.getActiveMembers Active shared-scale members used for configured domain planning.
+     * @param {ScaleMembersGetter} [options.getAllMembers] All members, including inactive ones, used for conflict validation.
+     * @param {ScaleMembersGetter} [options.getDataMembers] Members used for data-domain extraction; defaults to `getActiveMembers`.
      * @param {() => import("../spec/channel.js").Type} options.getType
-     * @param {(assembly: import("../spec/scale.js").Scale["assembly"] | undefined) => number[]} options.getLocusExtent
-     * @param {(interval: ScalarDomain | ComplexDomain) => number[]} options.fromComplexInterval
+     * @param {GetLocusExtent} options.getLocusExtent
+     * @param {FromComplexInterval} options.fromComplexInterval
      */
     constructor({
-        getMembers,
+        getActiveMembers,
         getAllMembers,
         getDataMembers,
         getType,
         getLocusExtent,
         fromComplexInterval,
     }) {
-        this.#getMembers = getMembers;
-        this.#getAllMembers = getAllMembers ?? getMembers;
-        this.#getDataMembers = getDataMembers ?? getMembers;
+        this.#getActiveMembers = getActiveMembers;
+        this.#getAllMembers = getAllMembers ?? getActiveMembers;
+        this.#getDataMembers = getDataMembers ?? getActiveMembers;
         this.#getType = getType;
         this.#getLocusExtent = getLocusExtent;
         this.#fromComplexInterval = fromComplexInterval;
@@ -147,10 +181,13 @@ export default class DomainPlanner {
      * @returns {any[]}
      */
     getDefaultDomain(extractDataDomain = false, locusAssembly) {
+        const type = this.#getType();
         return resolveDefaultDomain(
-            this.#getType(),
+            type,
             this.#getLocusExtent,
-            extractDataDomain ? this.getDataDomain() : undefined,
+            extractDataDomain && type !== LOCUS
+                ? this.getDataDomain()
+                : undefined,
             locusAssembly
         );
     }
@@ -194,7 +231,7 @@ export default class DomainPlanner {
         }
 
         const configuredDomain = resolveConfiguredDomain(
-            this.#getMembers(),
+            this.#getActiveMembers(),
             this.#fromComplexInterval,
             includeSelectionInitial
         );
@@ -298,91 +335,153 @@ function resolveConfiguredDomain(
         .filter((member) => member.contributesToDomain)
         .filter((member) => member.channelDef.scale?.domain);
 
-    /** @type {DomainArray[]} */
-    const domains = [];
-
-    /** @type {any} */
-    let selectionRefRuntime = undefined;
-    /** @type {string | undefined} */
-    let selectionRefDescription = undefined;
-    /** @type {SelectionDomainLinkInfo | undefined} */
-    let selectionRef = undefined;
-    let hasLiteralDomain = false;
+    /** @type {ConfiguredDomainResolutionState} */
+    const state = {
+        domains: [],
+        selectionRef: undefined,
+        selectionRuntime: undefined,
+        selectionDescription: undefined,
+        hasLiteralDomain: false,
+    };
 
     for (const member of domainMembers) {
-        const domainDef = member.channelDef.scale.domain;
-        if (isSelectionDomainRef(domainDef)) {
-            if (hasLiteralDomain) {
-                throw new Error(
-                    "Cannot mix selection-driven and literal configured domains on a shared scale."
-                );
-            }
+        const resolved = resolveConfiguredDomainMember(
+            member,
+            fromComplexInterval,
+            includeSelectionInitial
+        );
+
+        if (resolved.kind === "selection") {
+            mergeSelectionConfiguredDomain(state, resolved);
+            continue;
+        }
 
-            const resolved = resolveSelectionDomain(
+        mergeLiteralConfiguredDomain(state, resolved);
+    }
+
+    return finishConfiguredDomainResolution(state);
+}
+
+/**
+ * @param {ScaleResolutionMember} member
+ * @param {(interval: ScalarDomain | ComplexDomain) => number[]} fromComplexInterval
+ * @param {boolean} includeSelectionInitial
+ * @returns {ConfiguredDomainMemberResolution}
+ */
+function resolveConfiguredDomainMember(
+    member,
+    fromComplexInterval,
+    includeSelectionInitial
+) {
+    const domainDef = member.channelDef.scale.domain;
+    if (isSelectionDomainRef(domainDef)) {
+        return {
+            kind: "selection",
+            ...resolveSelectionDomain(
                 member,
                 domainDef,
                 fromComplexInterval,
                 includeSelectionInitial
-            );
+            ),
+        };
+    }
 
-            if (
-                selectionRef &&
-                (selectionRef.runtime !== resolved.runtime ||
-                    selectionRef.param !== resolved.param ||
-                    selectionRef.encoding !== resolved.encoding)
-            ) {
-                throw new Error(
-                    "Conflicting selection domain references on a shared scale: " +
-                        selectionRefDescription +
-                        " vs " +
-                        resolved.description +
-                        "."
-                );
-            }
+    if (isExprRef(domainDef)) {
+        return {
+            kind: "literal",
+            domain: resolveConfiguredIntervalDomain(
+                member.channelDef.type,
+                member.view.paramRuntime.createExpression(domainDef.expr)(),
+                fromComplexInterval
+            ),
+        };
+    }
 
-            selectionRefRuntime = resolved.runtime;
-            selectionRefDescription = resolved.description;
-            selectionRef = {
-                param: resolved.param,
-                encoding: resolved.encoding,
-                hasInitial:
-                    (selectionRef?.hasInitial ?? false) || resolved.hasInitial,
-                runtime: resolved.runtime,
-            };
-
-            if (resolved.domain) {
-                domains.push(resolved.domain);
-            }
-            continue;
-        }
+    return {
+        kind: "literal",
+        domain: resolveConfiguredIntervalDomain(
+            member.channelDef.type,
+            domainDef,
+            fromComplexInterval
+        ),
+    };
+}
 
-        if (selectionRefRuntime) {
-            throw new Error(
-                "Cannot mix literal configured domains with selection-driven domains on a shared scale."
-            );
-        }
+/**
+ * @param {ConfiguredDomainResolutionState} state
+ * @param {Extract<ConfiguredDomainMemberResolution, { kind: "selection" }>} resolved
+ */
+function mergeSelectionConfiguredDomain(state, resolved) {
+    if (state.hasLiteralDomain) {
+        throw new Error(
+            "Cannot mix selection-driven and literal configured domains on a shared scale."
+        );
+    }
 
-        hasLiteralDomain = true;
-        domains.push(
-            resolveConfiguredIntervalDomain(
-                member.channelDef.type,
-                domainDef,
-                fromComplexInterval
-            )
+    if (
+        state.selectionRef &&
+        (state.selectionRef.runtime !== resolved.runtime ||
+            state.selectionRef.param !== resolved.param ||
+            state.selectionRef.encoding !== resolved.encoding)
+    ) {
+        throw new Error(
+            "Conflicting selection domain references on a shared scale: " +
+                state.selectionDescription +
+                " vs " +
+                resolved.description +
+                "."
+        );
+    }
+
+    state.selectionRuntime = resolved.runtime;
+    state.selectionDescription = resolved.description;
+    state.selectionRef = {
+        param: resolved.param,
+        encoding: resolved.encoding,
+        hasInitial:
+            (state.selectionRef?.hasInitial ?? false) || resolved.hasInitial,
+        runtime: resolved.runtime,
+    };
+
+    if (resolved.domain) {
+        state.domains.push(resolved.domain);
+    }
+}
+
+/**
+ * @param {ConfiguredDomainResolutionState} state
+ * @param {Extract<ConfiguredDomainMemberResolution, { kind: "literal" }>} resolved
+ */
+function mergeLiteralConfiguredDomain(state, resolved) {
+    if (state.selectionRuntime) {
+        throw new Error(
+            "Cannot mix literal configured domains with selection-driven domains on a shared scale."
         );
     }
 
-    if (domains.length > 0) {
+    state.hasLiteralDomain = true;
+    state.domains.push(resolved.domain);
+}
+
+/**
+ * @param {ConfiguredDomainResolutionState} state
+ * @returns {{
+ *   domain: DomainArray | undefined,
+ *   selectionRef: SelectionDomainLinkInfo | undefined,
+ * }}
+ */
+function finishConfiguredDomainResolution(state) {
+    if (state.domains.length > 0) {
         return {
-            domain: domains.reduce((acc, curr) => acc.extendAll(curr)),
-            selectionRef,
+            domain: state.domains.reduce((acc, curr) => acc.extendAll(curr)),
+            selectionRef: state.selectionRef,
         };
     }
 
-    if (selectionRefRuntime) {
+    if (state.selectionRuntime) {
         // Selection refs are still the source of truth even when the
         // selection interval currently resolves to no domain.
-        return { domain: undefined, selectionRef };
+        return { domain: undefined, selectionRef: state.selectionRef };
     }
 
     return { domain: undefined, selectionRef: undefined };
@@ -422,7 +521,7 @@ function resolveSelectionDomain(
         resolvedChannel
     );
     const hasInitial = domainRef.initial !== undefined;
-    const interval = binding.selection.intervals[resolvedChannel];
+    const interval = binding.selection?.intervals[resolvedChannel];
     const description = paramName + "." + resolvedChannel;
     if (!interval || interval.length !== 2) {
         const initialDomain = includeSelectionInitial

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

@@ -1 +1 @@
-{"version":3,"file":"scaleInstanceManager.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleInstanceManager.js"],"names":[],"mappings":"AAMA;IA0BI;;;;;;OAMG;IACH,iFALG;QAAkH,eAAe,EAAzH,MAAM;YAAE,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,0BAA0B,EAAE,eAAe,CAAA;SAAE;QAC5E,aAAa,EAAjC,MAAM,IAAI;QACW,cAAc,GAAnC,MAAM,IAAI;QAC6D,cAAc,GAArF,MAAM,OAAO,0BAA0B,EAAE,OAAO,GAAG,SAAS;KAA0B,EAYhG;IAED;eA1CkC,OAAO,kBAAkB,EAAE,KAAK;MA4CjE;IAED;;;OAGG;IACH,0BAHW,OAAO,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,GAC1C,OAAO,qBAAqB,EAAE,OAAO,CAajD;IAED;;;OAGG;IACH,mBAHW,OAAO,kBAAkB,EAAE,KAAK;eAhET,OAAO,kBAAkB,EAAE,KAAK;MAqFjE;IAcD;;OAEG;IACH,wBAFW,OAAO,kBAAkB,EAAE,KAAK,QAc1C;IAED;;;OAGG;IACH,4CAHW,MAAM,IAAI,GACR,IAAI,CAShB;IAmFD,gBAGC;;CACJ"}
+{"version":3,"file":"scaleInstanceManager.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleInstanceManager.js"],"names":[],"mappings":"AAMA;IA0BI;;;;;;OAMG;IACH,iFALG;QAAkH,eAAe,EAAzH,MAAM;YAAE,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,0BAA0B,EAAE,eAAe,CAAA;SAAE;QAC5E,aAAa,EAAjC,MAAM,IAAI;QACW,cAAc,GAAnC,MAAM,IAAI;QAC6D,cAAc,GAArF,MAAM,OAAO,0BAA0B,EAAE,OAAO,GAAG,SAAS;KAA0B,EAYhG;IAED;eA1CkC,OAAO,kBAAkB,EAAE,KAAK;MA4CjE;IAED;;;OAGG;IACH,0BAHW,OAAO,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,GAC1C,OAAO,qBAAqB,EAAE,OAAO,CAajD;IAED;;;OAGG;IACH,mBAHW,OAAO,kBAAkB,EAAE,KAAK;eAhET,OAAO,kBAAkB,EAAE,KAAK;MAqFjE;IAcD;;OAEG;IACH,wBAFW,OAAO,kBAAkB,EAAE,KAAK,QAc1C;IAED;;;OAGG;IACH,4CAHW,MAAM,IAAI,GACR,IAAI,CAShB;IAwFD,gBAGC;;CACJ"}

package/dist/src/scales/scaleInstanceManager.js

@@ -147,10 +147,12 @@ export default class ScaleInstanceManager {
         const {
             assembly: _assembly,
             domainIndexer: _domainIndexer,
+            __rangeExprScope: _rangeExprScope,
             ...rest
         } = propsAny;
         void _assembly;
         void _domainIndexer;
+        void _rangeExprScope;
         return rest;
     }
 
@@ -168,11 +170,14 @@ export default class ScaleInstanceManager {
         this.#rangeExprRefListeners.forEach((fn) => fn.invalidate());
         this.#rangeExprRefListeners.clear();
 
+        const rangeExprScope = /** @type {any} */ (props).__rangeExprScope;
+        const paramRuntime =
+            rangeExprScope?.paramRuntime ?? this.#getParamRuntime();
+
         const resolved = resolveRange({
             range: props.range,
             reverse: props.reverse,
-            createExpression: (expr) =>
-                this.#getParamRuntime().createExpression(expr),
+            createExpression: (expr) => paramRuntime.createExpression(expr),
             registerExpr: (fn) => this.#rangeExprRefListeners.add(fn),
         });
 

package/dist/src/scales/scalePropsResolver.d.ts

@@ -7,15 +7,15 @@
  * @param {object} options
  * @param {Channel} options.channel
  * @param {import("../spec/channel.js").Type} options.dataType
- * @param {Set<ScaleResolutionMember>} options.members
+ * @param {ScaleResolutionMember[]} options.orderedMembers
  * @param {boolean} options.isExplicitDomain
  * @param {import("../spec/config.js").GenomeSpyConfig[]} options.configScopes
  * @returns {Scale}
  */
-export function resolveScalePropsBase({ channel, dataType, members, isExplicitDomain, configScopes, }: {
+export function resolveScalePropsBase({ channel, dataType, orderedMembers, isExplicitDomain, configScopes, }: {
     channel: Channel;
     dataType: import("../spec/channel.js").Type;
-    members: Set<ScaleResolutionMember>;
+    orderedMembers: ScaleResolutionMember[];
     isExplicitDomain: boolean;
     configScopes: import("../spec/config.js").GenomeSpyConfig[];
 }): Scale;

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

@@ -1 +1 @@
-{"version":3,"file":"scalePropsResolver.d.ts","sourceRoot":"","sources":["../../../src/scales/scalePropsResolver.js"],"names":[],"mappings":"AAcA;;;;GAIG;AAEH;;;;;;;;GAQG;AACH,uGAPG;IAAyB,OAAO,EAAxB,OAAO;IACoC,QAAQ,EAAnD,OAAO,oBAAoB,EAAE,IAAI;IACG,OAAO,EAA3C,GAAG,CAAC,qBAAqB,CAAC;IACT,gBAAgB,EAAjC,OAAO;IACgD,YAAY,EAAnE,OAAO,mBAAmB,EAAE,eAAe,EAAE;CACrD,GAAU,KAAK,CAsHjB;sBAlIY,OAAO,oBAAoB,EAAE,OAAO;oBACpC,OAAO,kBAAkB,EAAE,KAAK;oCAChC,OAAO,sBAAsB,EAAE,qBAAqB"}
+{"version":3,"file":"scalePropsResolver.d.ts","sourceRoot":"","sources":["../../../src/scales/scalePropsResolver.js"],"names":[],"mappings":"AAcA;;;;GAIG;AAEH;;;;;;;;GAQG;AACH,8GAPG;IAAyB,OAAO,EAAxB,OAAO;IACoC,QAAQ,EAAnD,OAAO,oBAAoB,EAAE,IAAI;IACA,cAAc,EAA/C,qBAAqB,EAAE;IACN,gBAAgB,EAAjC,OAAO;IACgD,YAAY,EAAnE,OAAO,mBAAmB,EAAE,eAAe,EAAE;CACrD,GAAU,KAAK,CA6IjB;sBAzJY,OAAO,oBAAoB,EAAE,OAAO;oBACpC,OAAO,kBAAkB,EAAE,KAAK;oCAChC,OAAO,sBAAsB,EAAE,qBAAqB"}

package/dist/src/scales/scalePropsResolver.js

@@ -1,5 +1,6 @@
 import { isDiscrete } from "vega-scale";
 import { isColorChannel } from "../encoder/encoder.js";
+import { isExprRef } from "../paramRuntime/paramUtils.js";
 
 import mergeObjects from "../utils/mergeObjects.js";
 import {
@@ -10,7 +11,6 @@ import {
 } from "../config/scaleConfig.js";
 import { applyLockedProperties, getDefaultScaleType } from "./scaleRules.js";
 import { INDEX, LOCUS } from "./scaleResolutionConstants.js";
-import { orderResolutionMembers } from "./resolutionMemberOrder.js";
 
 /**
  * @typedef {import("../spec/channel.js").Channel} Channel
@@ -22,7 +22,7 @@ import { orderResolutionMembers } from "./resolutionMemberOrder.js";
  * @param {object} options
  * @param {Channel} options.channel
  * @param {import("../spec/channel.js").Type} options.dataType
- * @param {Set<ScaleResolutionMember>} options.members
+ * @param {ScaleResolutionMember[]} options.orderedMembers
  * @param {boolean} options.isExplicitDomain
  * @param {import("../spec/config.js").GenomeSpyConfig[]} options.configScopes
  * @returns {Scale}
@@ -30,11 +30,13 @@ import { orderResolutionMembers } from "./resolutionMemberOrder.js";
 export function resolveScalePropsBase({
     channel,
     dataType,
-    members,
+    orderedMembers,
     isExplicitDomain,
     configScopes,
 }) {
-    const markTypes = [...members]
+    const memberList = orderedMembers;
+
+    const markTypes = memberList
         .map((member) =>
             typeof member.view.getMarkType == "function"
                 ? member.view.getMarkType()
@@ -42,7 +44,7 @@ export function resolveScalePropsBase({
         )
         .filter((markType) => !!markType);
 
-    const propArray = orderResolutionMembers(members)
+    const propArray = memberList
         .map((member) => member.channelDef.scale)
         .filter((props) => props !== undefined);
 
@@ -129,6 +131,27 @@ export function resolveScalePropsBase({
         // TODO: Props should be set more intelligently
     }
 
+    if (props.domainTransition === undefined) {
+        const hasExprDrivenDomain = memberList.some((member) =>
+            isExprRef(member.channelDef.scale?.domain)
+        );
+        props.domainTransition = !hasExprDrivenDomain;
+    }
+
+    if (
+        Array.isArray(props.range) &&
+        props.range.some(isExprRef) &&
+        memberList.length > 0
+    ) {
+        const rangeOwner = memberList.find(
+            (member) => member.channelDef.scale?.range !== undefined
+        )?.view;
+        if (rangeOwner) {
+            /** @type {any} */
+            (props).__rangeExprScope = rangeOwner;
+        }
+    }
+
     // By default, index and locus scales are zoomable, others are not.
     // Config can override this baseline via scale.zoom.
     if (!("zoom" in props)) {

package/dist/src/scales/scaleResolution.d.ts

@@ -27,10 +27,21 @@
  * @implements {ScaleResolutionApi}
  */
 export default class ScaleResolution implements ScaleResolutionApi {
+    /**
+     * Executes a group of member registrations without refreshing derived
+     * membership state until the callback completes.
+     *
+     * @template T
+     * @param {Iterable<ScaleResolution>} resolutions
+     * @param {() => T} callback
+     * @returns {T}
+     */
+    static registerInBatch<T>(resolutions: Iterable<ScaleResolution>, callback: () => T): T;
     /**
      * @param {Channel} channel
+     * @param {import("../view/view.js").default} [hostView]
      */
-    constructor(channel: import("../spec/channel.js").Channel);
+    constructor(channel: import("../spec/channel.js").Channel, hostView?: import("../view/view.js").default);
     channel: import("../spec/channel.js").Channel;
     /** @type {import("../spec/channel.js").Type} Data type (quantitative, nominal, etc...) */
     type: import("../spec/channel.js").Type;

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

@@ -1 +1 @@
-{"version":3,"file":"scaleResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleResolution.js"],"names":[],"mappings":"AAkDA;;;;;;;;GAQG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAwDI;;OAEG;IACH,2DAkCC;IAjCG,8CAAsB;IACtB,0FAA0F;IAC1F,MADW,OAAO,oBAAoB,EAAE,IAAI,CAC5B;IAEhB,iEAAiE;IACjE,MADW,MAAM,CACI;IAoEzB,2BASC;IAwBD;;;;;;;OAOG;IACH,4KAEC;IAED;;;OAGG;IACH,+KAEC;IAiCD,sCA0CC;IA0JD;;;OAGG;IACH,uBAHW,qBAAqB,GACnB,MAAM,OAAO,CAazB;IAED,gBAKC;IAkDD;;;;OAIG;IACH,0CAJW,OAAO,sBAAsB,EAAE,OAAO,aACtC,QAAQ,CAAC,OAAO,qBAAqB,EAAE,aAAa,CAAC,GACnD,MAAM,IAAI,CAkCtB;IAED;;OAEG;IACH,qCAEC;IAED,+BAiBC;IAmDD;;;;;;;;;;;OAWG;IACH,0BALa;QACR,QAAQ,EAAE,OAAO,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,GAAG,SAAS,CAAC;QACnE,oBAAoB,EAAE,OAAO,CAAA;KAC9B,CAeH;IAED;;;;;;;OAOG;IACH,wBAFa,OAAO,kBAAkB,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,SAAS,CAShE;IAwFD;;;;;OAKG;IACH,oBAYC;IAED;;;;;OAKG;IACH,0BA2BC;IA+HD;;OAEG;IACH;eAj4BkC,OAAO,kBAAkB,EAAE,KAAK;MAw4BjE;IAED;;;;;;OAMG;IACH;eAj5BkC,OAAO,kBAAkB,EAAE,KAAK;MAm5BjE;IAED;;;;OAIG;IACH;eA15BkC,OAAO,kBAAkB,EAAE,KAAK;MAm6BjE;IAED,mBAEC;IAED;;;;OAIG;IACH,+DAEC;IAED;;OAEG;IACH,oBAFa,mFAA6B,CASzC;IAED;;OAEG;IACH;;;;MAqBC;IAED;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,sBASC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,eAJW,mFAA6B,aAC7B,OAAO,GAAG,MAAM,iBAK1B;IAED;;;;OAIG;IACH,qBAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,uBAFW,MAAM,yDAUhB;IAED;;OAEG;IACH,iBAFW,MAAM,yDAIhB;IAED;;;OAGG;IACH,qBAHW,MAAM,+CAAmB,GACvB,MAAM,CAIlB;IAED;;;OAGG;IACH,8BAHW,kFAA4B,GAC1B,MAAM,EAAE,CAOpB;;CACJ;kCA1oC+B,CAAC,SAApB,6CAAkB;;;;UAGrB,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB;yBAChD,OAAO;;sBAlCV,+BAA+B;sBAA/B,+BAA+B;wBAA/B,+BAA+B;wBAA/B,+BAA+B;6BAA/B,+BAA+B"}
+{"version":3,"file":"scaleResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleResolution.js"],"names":[],"mappings":"AAoDA;;;;;;;;GAQG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IA6cI;;;;;;;;OAQG;IACH,uBALa,CAAC,eACH,QAAQ,CAAC,eAAe,CAAC,YACzB,MAAM,CAAC,GACL,CAAC,CAqBb;IAlaD;;;OAGG;IACH,sEAFW,OAAO,iBAAiB,EAAE,OAAO,EAsC3C;IAnCG,8CAAsB;IACtB,0FAA0F;IAC1F,MADW,OAAO,oBAAoB,EAAE,IAAI,CAC5B;IAEhB,iEAAiE;IACjE,MADW,MAAM,CACI;IA0EzB,2BASC;IAwBD;;;;;;;OAOG;IACH,4KAEC;IAED;;;OAGG;IACH,+KAEC;IAiCD,sCA6CC;IA+MD;;;OAGG;IACH,uBAHW,qBAAqB,GACnB,MAAM,OAAO,CAazB;IAED,gBAMC;IAoFD;;;;OAIG;IACH,0CAJW,OAAO,sBAAsB,EAAE,OAAO,aACtC,QAAQ,CAAC,OAAO,qBAAqB,EAAE,aAAa,CAAC,GACnD,MAAM,IAAI,CAkCtB;IAED;;OAEG;IACH,qCAEC;IAED,+BAiBC;IAuED;;;;;;;;;;;OAWG;IACH,0BALa;QACR,QAAQ,EAAE,OAAO,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,GAAG,SAAS,CAAC;QACnE,oBAAoB,EAAE,OAAO,CAAA;KAC9B,CAeH;IAED;;;;;;;OAOG;IACH,wBAFa,OAAO,kBAAkB,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,SAAS,CAShE;IAgGD;;;;;OAKG;IACH,oBAYC;IAED;;;;;OAKG;IACH,0BA0BC;IAoID;;OAEG;IACH;eAlhCkC,OAAO,kBAAkB,EAAE,KAAK;MAyhCjE;IAED;;;;;;OAMG;IACH;eAliCkC,OAAO,kBAAkB,EAAE,KAAK;MAyiCjE;IAED;;;;OAIG;IACH;eAhjCkC,OAAO,kBAAkB,EAAE,KAAK;MAyjCjE;IAED,mBASC;IAED;;;;OAIG;IACH,+DAEC;IAED;;OAEG;IACH,oBAFa,mFAA6B,CASzC;IAED;;OAEG;IACH;;;;MAqBC;IAED;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,sBASC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,eAJW,mFAA6B,aAC7B,OAAO,GAAG,MAAM,iBAK1B;IAED;;;;OAIG;IACH,qBAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,uBAFW,MAAM,yDAUhB;IAED;;OAEG;IACH,iBAFW,MAAM,yDAIhB;IAED;;;OAGG;IACH,qBAHW,MAAM,+CAAmB,GACvB,MAAM,CAIlB;IAED;;;OAGG;IACH,8BAHW,kFAA4B,GAC1B,MAAM,EAAE,CAOpB;;CACJ;kCAvyC+B,CAAC,SAApB,6CAAkB;;;;UAGrB,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB;yBAChD,OAAO;;sBApCV,+BAA+B;sBAA/B,+BAA+B;wBAA/B,+BAA+B;wBAA/B,+BAA+B;6BAA/B,+BAA+B"}