@genome-spy/core 0.44.0 → 0.46.0

package/dist/src/view/paramMediator.js

@@ -0,0 +1,338 @@
+import { isString } from "vega-util";
+import createFunction from "../utils/expression.js";
+
+/**
+ * A class that manages parameters and expressions.
+ * Supports nesting and scoped parameters.
+ *
+ * @typedef {import("../utils/expression.js").ExpressionFunction & { addListener: (listener: () => void) => void, invalidate: () => void, identifier: () => string}} ExprRefFunction
+ */
+export default class ParamMediator {
+    /**
+     * @typedef {import("../spec/parameter.js").VariableParameter} VariableParameter
+     * @typedef {(value: any) => void} ParameterSetter
+     */
+
+    /** @type {Map<string, any>} */
+    #paramValues;
+
+    /**
+     * @type {Map<string, Set<() => void>>}
+     * @protected
+     */
+    paramListeners;
+
+    /** @type {Map<string, (value: any) => void>} */
+    #allocatedSetters = new Map();
+
+    /** @type {Map<string, ExprRefFunction>} */
+    #expressions = new Map();
+
+    /** @type {Map<string, VariableParameter>} */
+    #paramConfigs = new Map();
+
+    /** @type {() => ParamMediator} */
+    #parentFinder;
+
+    /**
+     * @param {() => ParamMediator} [parentFinder]
+     *      An optional function that returns the parent mediator.
+     *      N.B. The function must always return the same mediator for the same parent,
+     *      i.e., the changing the structure of the hierarchy is NOT supported.
+     */
+    constructor(parentFinder) {
+        this.#parentFinder = parentFinder ?? (() => undefined);
+
+        this.#paramValues = new Map();
+        this.paramListeners = new Map();
+    }
+
+    /**
+     * @param {VariableParameter} param
+     * @returns {ParameterSetter}
+     */
+    registerParam(param) {
+        if ("value" in param && "expr" in param) {
+            throw new Error(
+                "Parameter must not have both value and expr: " + param.name
+            );
+        }
+
+        /** @type {ParameterSetter} */
+        let setter;
+
+        if ("value" in param) {
+            setter = this.allocateSetter(param.name, param.value);
+        } else if ("expr" in param) {
+            const expr = this.createExpression(param.expr);
+            // TODO: getSetter(param) should return a setter that throws if
+            // modifying the value is attempted.
+            const realSetter = this.allocateSetter(param.name, expr(null));
+            expr.addListener(() => realSetter(expr(null)));
+            // NOP
+            setter = (_) => undefined;
+        }
+
+        this.#paramConfigs.set(param.name, param);
+
+        return setter;
+    }
+
+    /**
+     *
+     * @param {string} paramName
+     * @param {T} initialValue
+     * @param {boolean} [passive] If true, the setter will not notify listeners when the value changes.
+     * @returns {(value: T) => void}
+     * @template T
+     */
+    allocateSetter(paramName, initialValue, passive = false) {
+        if (this.#allocatedSetters.has(paramName)) {
+            throw new Error(
+                "Setter already allocated for parameter: " + paramName
+            );
+        }
+
+        /** @type {(value: any) => void} */
+        const setter = (value) => {
+            const previous = this.#paramValues.get(paramName);
+            if (value !== previous) {
+                this.#paramValues.set(paramName, value);
+
+                const listeners = this.paramListeners.get(paramName);
+                if (listeners && !passive) {
+                    for (const listener of listeners) {
+                        listener();
+                    }
+                }
+            }
+        };
+
+        setter(initialValue);
+
+        this.#allocatedSetters.set(paramName, setter);
+
+        return setter;
+    }
+
+    /**
+     * Gets an existing setter for a parameter. Throws if the setter is not found.
+     * @param {string} paramName
+     */
+    getSetter(paramName) {
+        const setter = this.#allocatedSetters.get(paramName);
+        if (!setter) {
+            throw new Error("Setter not found for parameter: " + paramName);
+        }
+        return setter;
+    }
+
+    /**
+     * Get the value of a parameter from this mediator.
+     * @param {string} paramName
+     */
+    getValue(paramName) {
+        return this.#paramValues.get(paramName);
+    }
+
+    /**
+     * Get the value of a parameter from this mediator or the ancestors.
+     * @param {string} paramName
+     */
+    findValue(paramName) {
+        const mediator = this.findMediatorForParam(paramName);
+        return mediator?.getValue(paramName);
+    }
+
+    /**
+     * Returns configs for all parameters that have been registered using `registerParam`.
+     */
+    get paramConfigs() {
+        return /** @type {ReadonlyMap<string, VariableParameter>} */ (
+            this.#paramConfigs
+        );
+    }
+
+    /**
+     *
+     * @param {string} paramName
+     * @returns {ParamMediator}
+     * @protected
+     */
+    findMediatorForParam(paramName) {
+        if (this.#paramValues.has(paramName)) {
+            return this;
+        } else {
+            return this.#parentFinder()?.findMediatorForParam(paramName);
+        }
+    }
+
+    // TODO: deallocateSetter
+
+    /**
+     * Parse expr and return a function that returns the value of the parameter.
+     *
+     * @param {string} expr
+     */
+    createExpression(expr) {
+        if (this.#expressions.has(expr)) {
+            return this.#expressions.get(expr);
+        }
+
+        const globalObject = {};
+
+        /** @type {ExprRefFunction} */
+        const fn = /** @type {any} */ (createFunction(expr, globalObject));
+
+        /** @type {Map<string, ParamMediator>} */
+        const mediatorsForParams = new Map();
+
+        for (const param of fn.globals) {
+            const mediator = this.findMediatorForParam(param);
+            if (!mediator) {
+                throw new Error(
+                    `Unknown variable "${param}" in expression: ${expr}`
+                );
+            }
+
+            mediatorsForParams.set(param, mediator);
+
+            Object.defineProperty(globalObject, param, {
+                enumerable: true,
+                get() {
+                    return mediator.getValue(param);
+                },
+            });
+        }
+        // TODO: There should be a way to "materialize" the global object when
+        // it is used in expressions in transformation batches, i.e., when the same
+        // expression is applied to multiple data objects. In that case, the global
+        // object remains constant and the Map lookups cause unnecessary overhead.
+
+        // Keep track of them so that they can be detached later
+        const myListeners = new Set();
+
+        /**
+         *
+         * @param {() => void} listener
+         */
+        fn.addListener = (listener) => {
+            for (const [param, mediator] of mediatorsForParams) {
+                const listeners =
+                    mediator.paramListeners.get(param) ?? new Set();
+                mediator.paramListeners.set(param, listeners);
+
+                listeners.add(listener);
+                myListeners.add(listener);
+            }
+        };
+
+        /**
+         * Detach listeners. This must be called if the expression is no longer used.
+         * TODO: What if the expression is used in multiple places?
+         */
+        fn.invalidate = () => {
+            for (const [param, mediator] of mediatorsForParams) {
+                for (const listener of myListeners) {
+                    mediator.paramListeners.get(param)?.delete(listener);
+                }
+            }
+        };
+
+        // TODO: This should contain unique identifier for each parameter.
+        // As the same parameter name may be used in different branches of the
+        // hierarchy, they should be distinguished by a unique identifier, e.g.,
+        // a serial number of something similar.
+        fn.identifier = () => fn.code;
+
+        this.#expressions.set(expr, fn);
+
+        return fn;
+    }
+
+    /**
+     * A convenience method for evaluating an expression.
+     *
+     * @param {string} expr
+     */
+    evaluateAndGet(expr) {
+        const fn = this.createExpression(expr);
+        return fn();
+    }
+}
+
+/**
+ * @param {any} x
+ * @returns {x is import("../spec/parameter.js").ExprRef}
+ */
+export function isExprRef(x) {
+    return typeof x == "object" && x != null && "expr" in x && isString(x.expr);
+}
+
+/**
+ * Removes ExprRef from the type and checks that the value is not an ExprRef.
+ * This is designed to be used with `activateExprRefProps`.
+ *
+ * @param {T | import("../spec/parameter.js").ExprRef} x
+ * @template T
+ * @returns {T}
+ */
+export function withoutExprRef(x) {
+    if (isExprRef(x)) {
+        throw new Error(
+            `ExprRef ${JSON.stringify(
+                x
+            )} not allowed here. Expected a scalar value.`
+        );
+    }
+    return /** @type {T} */ (x);
+}
+
+/**
+ * Takes a record of properties that may have ExprRefs as values. Converts the
+ * ExprRefs to getters and setups a listener that is called when any of the
+ * expressions (upstream parameters) change.
+ *
+ * @param {ParamMediator} paramMediator
+ * @param {T} props The properties object
+ * @param {(props: (keyof T)[]) => void} [listener] Listener to be called when any of the expressions change
+ * @returns T
+ * @template {Record<string, any | import("../spec/parameter.js").ExprRef>} T
+ */
+export function activateExprRefProps(paramMediator, props, listener) {
+    /** @type {Record<string, any | import("../spec/parameter.js").ExprRef>} */
+    const activatedProps = { ...props };
+
+    /** @type {(keyof T)[]} */
+    const alteredProps = [];
+
+    const batchPropertyChange = (/** @type {keyof T} */ prop) => {
+        alteredProps.push(prop);
+        if (alteredProps.length === 1) {
+            queueMicrotask(() => {
+                listener(alteredProps.slice());
+                alteredProps.length = 0;
+            });
+        }
+    };
+
+    for (const [key, value] of Object.entries(props)) {
+        if (isExprRef(value)) {
+            const fn = paramMediator.createExpression(value.expr);
+            if (listener) {
+                fn.addListener(() => batchPropertyChange(key));
+            }
+
+            Object.defineProperty(activatedProps, key, {
+                enumerable: true,
+                get() {
+                    return fn();
+                },
+            });
+        } else {
+            activatedProps[key] = value;
+        }
+    }
+
+    return /** @type {T} */ (activatedProps);
+}

package/dist/src/view/paramMediator.test.js

@@ -0,0 +1,224 @@
+import { describe, expect, test } from "vitest";
+import ParamMediator, { activateExprRefProps } from "./paramMediator.js";
+
+describe("Single-level ParamMediator", () => {
+    test("Trivial case", () => {
+        const pm = new ParamMediator();
+        pm.registerParam({ name: "foo", value: 42 });
+        expect(pm.getValue("foo")).toBe(42);
+    });
+
+    test("Setter", () => {
+        const pm = new ParamMediator();
+        const setter = pm.allocateSetter("foo", 42);
+        expect(pm.getValue("foo")).toBe(42);
+
+        setter(43);
+        expect(pm.getValue("foo")).toBe(43);
+    });
+
+    test("Expressions have access to parameters", () => {
+        const pm = new ParamMediator();
+        pm.registerParam({ name: "foo", value: 42 });
+        const expr = pm.createExpression("foo + 1");
+        expect(expr()).toBe(43);
+    });
+
+    test("Throws on an unknown parameter", () => {
+        const pm = new ParamMediator();
+        expect(() => pm.createExpression("foo")).toThrow();
+    });
+
+    test("Listener on an expression gets called (only) when a parameter changes", () => {
+        const pm = new ParamMediator();
+        const setter = pm.allocateSetter("foo", 42);
+        const expr = pm.createExpression("foo + 1");
+
+        let result;
+        let calls = 0;
+
+        expr.addListener(() => {
+            result = expr();
+            calls++;
+        });
+
+        setter(50);
+        expect(result).toBe(51);
+        expect(calls).toBe(1);
+
+        setter(60);
+        expect(result).toBe(61);
+        expect(calls).toBe(2);
+
+        setter(60);
+        expect(result).toBe(61);
+        expect(calls).toBe(2);
+    });
+
+    test("Passive parameter does not trigger listeners", () => {
+        const pm = new ParamMediator();
+        const setter = pm.allocateSetter("foo", 42, true);
+        const expr = pm.createExpression("foo");
+
+        let result = expr();
+
+        expr.addListener(() => (result = expr()));
+
+        setter(50);
+        expect(result).toBe(42);
+    });
+
+    test("Expression invalidation", () => {
+        const pm = new ParamMediator();
+        const setter = pm.allocateSetter("foo", 42);
+        const expr = pm.createExpression("foo + 1");
+
+        let result = expr();
+        expect(result).toBe(43);
+
+        expr.addListener(() => (result = expr()));
+
+        setter(50);
+        expect(result).toBe(51);
+
+        expr.invalidate();
+        // Listeners should be invalidated now: the result must remain the same.
+        setter(60);
+        expect(result).toBe(51);
+    });
+
+    test("Expression parameter handles dependencies", () => {
+        const pm = new ParamMediator();
+        const setter = pm.registerParam({ name: "foo", value: 42 });
+        pm.registerParam({ name: "bar", expr: "foo + 1" });
+        pm.registerParam({ name: "baz", expr: "bar + 2" });
+
+        const expr = pm.createExpression("baz");
+
+        let result = expr();
+        expect(result).toBe(45);
+
+        expr.addListener(() => (result = expr()));
+
+        setter(52);
+        expect(result).toBe(55);
+    });
+
+    test("Throws if both value and expr are provided", () => {
+        const pm = new ParamMediator();
+        expect(() =>
+            pm.registerParam({ name: "foo", value: 42, expr: "bar" })
+        ).toThrow();
+    });
+});
+
+describe("Nested ParamMediators", () => {
+    test("Value in parent", () => {
+        const parent = new ParamMediator();
+        const child = new ParamMediator(() => parent);
+
+        parent.registerParam({ name: "foo", value: 42 });
+        expect(parent.findValue("foo")).toBe(42);
+        expect(child.findValue("foo")).toBe(42);
+    });
+
+    test("Value in child", () => {
+        const parent = new ParamMediator();
+        const child = new ParamMediator(() => parent);
+
+        child.registerParam({ name: "foo", value: 42 });
+        expect(parent.findValue("foo")).toBeUndefined();
+        expect(child.findValue("foo")).toBe(42);
+    });
+
+    test("Child overrides parent", () => {
+        const parent = new ParamMediator();
+        const child = new ParamMediator(() => parent);
+
+        parent.registerParam({ name: "foo", value: 1 });
+        child.registerParam({ name: "foo", value: 2 });
+
+        expect(parent.findValue("foo")).toBe(1);
+        expect(child.findValue("foo")).toBe(2);
+    });
+
+    test("Expression", () => {
+        const parent = new ParamMediator();
+        const child = new ParamMediator(() => parent);
+
+        parent.registerParam({ name: "foo", value: 1 });
+        child.registerParam({ name: "bar", value: 2 });
+
+        const expr = child.createExpression("foo + bar");
+        expect(expr()).toBe(3);
+    });
+
+    test("Listener on an expression", () => {
+        const parent = new ParamMediator();
+        const child = new ParamMediator(() => parent);
+
+        const parentSetter = parent.allocateSetter("foo", 1);
+        const childSetter = parent.allocateSetter("bar", 2);
+
+        const expr = child.createExpression("foo + bar");
+
+        let result = expr();
+        expr.addListener(() => (result = expr()));
+
+        expect(result).toBe(3);
+
+        parentSetter(10);
+        expect(result).toBe(12);
+
+        childSetter(20);
+        expect(result).toBe(30);
+    });
+});
+
+test("activateExprRefProps", async () => {
+    const pm = new ParamMediator();
+
+    const fooSetter = pm.registerParam({ name: "foo", value: 7 });
+    const barSetter = pm.registerParam({ name: "bar", value: 11 });
+
+    /** @type {Record<string, any | import("../spec/parameter.js").ExprRef} */
+    const props = {
+        a: 42,
+        b: { expr: "foo" },
+        c: { expr: "bar" },
+    };
+
+    /** @type {string[]} */
+    let altered = [];
+
+    const activatedProps = activateExprRefProps(pm, props, (props) => {
+        altered = props;
+    });
+
+    expect(activatedProps).toEqual({
+        a: 42,
+        b: 7,
+        c: 11,
+    });
+
+    fooSetter(8);
+
+    // Let the scheduled microtask call the listener
+    await Promise.resolve();
+
+    expect(altered).toEqual(["b"]);
+
+    fooSetter(1);
+    barSetter(2);
+
+    // Let the scheduled microtask call the listener
+    await Promise.resolve();
+
+    expect(altered).toEqual(["b", "c"]);
+
+    expect(activatedProps).toEqual({
+        a: 42,
+        b: 1,
+        c: 2,
+    });
+});

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

@@ -1 +1 @@
-{"version":3,"file":"scaleResolution.d.ts","sourceRoot":"","sources":["../../../src/view/scaleResolution.js"],"names":[],"mappings":"AAy6BA;;;;;;;;;;GAUG;AACH,6CAFW,OAAO,WAAW,EAAE,OAAO,GAAG,OAAO,WAAW,EAAE,OAAO,EAAE,QA4BrE;AAh6BD,0CAA2C;AAC3C,gCAAiC;AACjC,gCAAiC;AACjC,4BAA6B;AAC7B,4BAA6B;AAE7B;;;;GAIG;AACH;;;;;;;GAOG;AACH;IAyCI;;OAEG;IACH,2DASC;IARG,8CAAsB;IACtB,oDAAoD;IACpD,SADW,gBAAgB,EAAE,CACZ;IACjB,+DAA+D;IAC/D,MADW,MAAM,CACD;IAEhB,iEAAiE;IACjE,MADW,MAAM,CACI;IAOzB;;;;;;;OAOG;IACH,4KAEC;IAED;;;OAGG;IACH,+KAEC;IAcD;;;;;;OAMG;IACH,kHA0BC;IAkLD;;;;OAIG;IACH,qEAMC;IAED;;;;OAIG;IACH,+DAQC;IAED;;OAEG;IACH,oBAyCC;IAED;;OAEG;IACH;eA3WkC,OAAO,kBAAkB,EAAE,KAAK;MAkZjE;IAED,mBAEC;IAED;;OAEG;IACH,oBAFa,mFAA6B,CAOzC;IAED;;;;OAIG;IACH,oBAKC;IAED;;OAEG;IACH,sBAGC;IAUD;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CAwEnB;IAED;;;;;;OAMG;IACH,eAJW,mFAA6B,aAC7B,OAAO,GAAG,MAAM,iBAgD1B;IAED;;;;OAIG;IACH,qBAcC;IAED;;;;;OAKG;IACH,uBAOC;IA8DD;;;OAGG;IACH,aAFa,OAAO,qBAAqB,EAAE,OAAO,CAajD;IAID;;;;;OAKG;IACH,uBAFW,MAAM,yDAUhB;IAED;;OAEG;IACH,iBAFW,MAAM,yDAKhB;IAED;;;OAGG;IACH,6EAFa,MAAM,CAQlB;IAED;;;OAGG;IACH,mHAFa,MAAM,EAAE,CAOpB;;CA6BJ;wIA5xBY;IAAC,IAAI,EAAE,OAAO,eAAe,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,CAAC,CAAA;CAAC"}
+{"version":3,"file":"scaleResolution.d.ts","sourceRoot":"","sources":["../../../src/view/scaleResolution.js"],"names":[],"mappings":"AA86BA;;;;;;;;;;GAUG;AACH,6CAFW,OAAO,WAAW,EAAE,OAAO,GAAG,OAAO,WAAW,EAAE,OAAO,EAAE,QA4BrE;AAr6BD,0CAA2C;AAC3C,gCAAiC;AACjC,gCAAiC;AACjC,4BAA6B;AAC7B,4BAA6B;AAE7B;;;;GAIG;AACH;;;;;;;GAOG;AACH;IAyCI;;OAEG;IACH,2DASC;IARG,8CAAsB;IACtB,oDAAoD;IACpD,SADW,gBAAgB,EAAE,CACZ;IACjB,+DAA+D;IAC/D,MADW,MAAM,CACD;IAEhB,iEAAiE;IACjE,MADW,MAAM,CACI;IAWzB;;;;;;;OAOG;IACH,4KAEC;IAED;;;OAGG;IACH,+KAEC;IAcD;;;;;;OAMG;IACH,kHA0BC;IAmLD;;;;OAIG;IACH,qEAMC;IAED;;;;OAIG;IACH,+DAQC;IAED;;OAEG;IACH,oBAyCC;IAED;;OAEG;IACH;eAhXkC,OAAO,kBAAkB,EAAE,KAAK;MAuZjE;IAED,mBAEC;IAED;;OAEG;IACH,oBAFa,mFAA6B,CAOzC;IAED;;;;OAIG;IACH,oBAKC;IAED;;OAEG;IACH,sBAGC;IAUD;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CAwEnB;IAED;;;;;;OAMG;IACH,eAJW,mFAA6B,aAC7B,OAAO,GAAG,MAAM,iBAgD1B;IAED;;;;OAIG;IACH,qBAcC;IAED;;;;;OAKG;IACH,uBAOC;IA8DD;;;OAGG;IACH,aAFa,OAAO,qBAAqB,EAAE,OAAO,CAajD;IAID;;;;;OAKG;IACH,uBAFW,MAAM,yDAUhB;IAED;;OAEG;IACH,iBAFW,MAAM,yDAKhB;IAED;;;OAGG;IACH,6EAFa,MAAM,CAQlB;IAED;;;OAGG;IACH,mHAFa,MAAM,EAAE,CAOpB;;CA6BJ;wIAjyBY;IAAC,IAAI,EAAE,OAAO,eAAe,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,CAAC,CAAA;CAAC"}

package/dist/src/view/scaleResolution.js

@@ -36,7 +36,7 @@ import { NominalDomain } from "../utils/domainArray.js";
 import { easeCubicInOut } from "d3-ease";
 import { asArray, shallowArrayEquals } from "../utils/arrayUtils.js";
 import eerp from "../utils/eerp.js";
-import { isExprRef } from "../marks/mark.js";
+import { isExprRef } from "./paramMediator.js";
 
 // Register scaleLocus to Vega-Scale.
 // Loci are discrete but the scale's domain can be adjusted in a continuous manner.
@@ -100,7 +100,7 @@ export default class ScaleResolution {
      * Keeps track of the expression references in the range. If range is modified,
      * new expressions are created and the old ones must be invalidated.
      *
-     * @type {Set<import("../paramBroker.js").ExprRefFunction>}
+     * @type {Set<import("./paramMediator.js").ExprRefFunction>}
      */
     #rangeExprRefListeners = new Set();
 
@@ -118,8 +118,12 @@ export default class ScaleResolution {
         this.name = undefined;
     }
 
+    get #firstMemberView() {
+        return this.members[0].view;
+    }
+
     get #viewContext() {
-        return this.members[0].view.context;
+        return this.#firstMemberView.context;
     }
 
     /**
@@ -338,9 +342,10 @@ export default class ScaleResolution {
 
             expressions = range.map((elem) => {
                 if (isExprRef(elem)) {
-                    const fn = this.#viewContext.paramBroker.createExpression(
-                        elem.expr
-                    );
+                    const fn =
+                        this.#firstMemberView.paramMediator.createExpression(
+                            elem.expr
+                        );
                     fn.addListener(evaluateAndSet);
                     this.#rangeExprRefListeners.add(fn);
                     return () => fn(null);

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

@@ -84,6 +84,8 @@ export default class View {
      * @type {Record<import("../spec/channel.js").PrimaryPositionalChannel, boolean>}
      */
     needsAxes: Record<import("../spec/channel.js").PrimaryPositionalChannel, boolean>;
+    /** @type {ParamMediator} */
+    paramMediator: ParamMediator;
     getPadding(): Padding;
     /**
      * Returns a padding that indicates how much axes and titles extend over the plot area.
@@ -267,7 +269,7 @@ export default class View {
      * Returns `true` if this view and its children supports picking.
      */
     isPickingSupported(): boolean;
-    getTitleText(): string;
+    getTitleText(): any;
     /**
      * @param {any} key string
      * @param {function(key?):T} callable A function that produces a value to be cached
@@ -321,6 +323,7 @@ export type ViewOptions = {
      */
     contributesToScaleDomain?: boolean;
 };
+import ParamMediator from "./paramMediator.js";
 import Padding from "./layout/padding.js";
 import { FlexDimensions } from "./layout/flexLayout.js";
 //# sourceMappingURL=view.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../../src/view/view.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../../src/view/view.js"],"names":[],"mappings":"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"}