@genome-spy/core 0.72.0 → 0.73.0

package/dist/src/genome/genomeStore.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Resolves genome assemblies for locus scales.
+ *
+ * Keeps configured genome definitions and loaded `Genome` instances, supports
+ * named and inline assemblies, and deduplicates concurrent URL loads.
+ *
+ * `ensureAssembly(...)` is the async loading boundary. `getGenome(...)` is
+ * synchronous and expects required URL-backed assemblies to be ensured first.
+ *
+ * The default assembly comes from root `assembly`, a single configured genome,
+ * or a single already-loaded built-in genome.
+ */
 export default class GenomeStore {
     /**
      * @param {string} baseUrl
@@ -9,12 +21,31 @@ export default class GenomeStore {
     /**
      * @param {import("../spec/genome.js").GenomeConfig} genomeConfig
      */
-    initialize(genomeConfig: import("../spec/genome.js").GenomeConfig): Promise<void[]>;
+    initialize(genomeConfig: import("../spec/genome.js").GenomeConfig): Promise<void>;
     /**
-     * @param {string} [name] If not given, a default genome is returned.
+     * @param {Map<string, import("../spec/root.js").NamedGenomeConfig>} genomesByName
+     * @param {string} [defaultAssembly]
+     */
+    configureGenomes(genomesByName: Map<string, import("../spec/root.js").NamedGenomeConfig>, defaultAssembly?: string): void;
+    /**
+     * @returns {string | undefined}
+     */
+    getDefaultAssemblyName(): string | undefined;
+    /**
+     * @param {(string | import("../spec/scale.js").InlineLocusAssembly | undefined)[]} assemblies
+     */
+    ensureAssemblies(assemblies: (string | import("../spec/scale.js").InlineLocusAssembly | undefined)[]): Promise<void>;
+    /**
+     * @param {string | import("../spec/scale.js").InlineLocusAssembly} assembly
+     * @returns {Promise<Genome>}
+     */
+    ensureAssembly(assembly: string | import("../spec/scale.js").InlineLocusAssembly): Promise<Genome>;
+    /**
+     * @param {string | import("../spec/scale.js").InlineLocusAssembly} [name] If not given, a default genome is returned.
      * @returns {Genome}
      */
-    getGenome(name?: string): Genome;
+    getGenome(name?: string | import("../spec/scale.js").InlineLocusAssembly): Genome;
+    #private;
 }
 import Genome from "./genome.js";
 //# sourceMappingURL=genomeStore.d.ts.map

package/dist/src/genome/genomeStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"genomeStore.d.ts","sourceRoot":"","sources":["../../../src/genome/genomeStore.js"],"names":[],"mappings":"AAEA;IACI;;OAEG;IACH,qBAFW,MAAM,EAMhB;IAHG,kCAAkC;IAClC,SADW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CACN;IACxB,gBAAsB;IAG1B;;OAEG;IAEH,yBAHW,OAAO,mBAAmB,EAAE,YAAY,mBAYlD;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAuBlB;CACJ;mBArDkB,aAAa"}
+{"version":3,"file":"genomeStore.d.ts","sourceRoot":"","sources":["../../../src/genome/genomeStore.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH;IACI;;OAEG;IACH,qBAFW,MAAM,EAahB;IAVG,kCAAkC;IAClC,SADW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CACN;IAQxB,gBAAsB;IAkB1B;;OAEG;IACH,yBAFW,OAAO,mBAAmB,EAAE,YAAY,iBAMlD;IAED;;;OAGG;IACH,gCAHW,GAAG,CAAC,MAAM,EAAE,OAAO,iBAAiB,EAAE,iBAAiB,CAAC,oBACxD,MAAM,QAShB;IAED;;OAEG;IACH,0BAFa,MAAM,GAAG,SAAS,CAmB9B;IAED;;OAEG;IACH,6BAFW,CAAC,MAAM,GAAG,OAAO,kBAAkB,EAAE,mBAAmB,GAAG,SAAS,CAAC,EAAE,iBAuBjF;IAED;;;OAGG;IACH,yBAHW,MAAM,GAAG,OAAO,kBAAkB,EAAE,mBAAmB,GACrD,OAAO,CAAC,MAAM,CAAC,CAuB3B;IAED;;;OAGG;IACH,iBAHW,MAAM,GAAG,OAAO,kBAAkB,EAAE,mBAAmB,GACrD,MAAM,CAuDlB;;CAwOJ;mBAhbkB,aAAa"}

package/dist/src/genome/genomeStore.js

@@ -1,5 +1,17 @@
 import Genome from "./genome.js";
 
+/**
+ * Resolves genome assemblies for locus scales.
+ *
+ * Keeps configured genome definitions and loaded `Genome` instances, supports
+ * named and inline assemblies, and deduplicates concurrent URL loads.
+ *
+ * `ensureAssembly(...)` is the async loading boundary. `getGenome(...)` is
+ * synchronous and expects required URL-backed assemblies to be ensured first.
+ *
+ * The default assembly comes from root `assembly`, a single configured genome,
+ * or a single already-loaded built-in genome.
+ */
 export default class GenomeStore {
     /**
      * @param {string} baseUrl
@@ -7,48 +19,427 @@ export default class GenomeStore {
     constructor(baseUrl) {
         /** @type {Map<string, Genome>} */
         this.genomes = new Map();
+
+        this.#configuredGenomesByName = new Map();
+        this.#loadingPromisesByName = new Map();
+        this.#inlineAssemblyNamesByKey = new Map();
+        this.#nextInlineAssemblyIndex = 0;
+        this.#defaultAssemblyName = undefined;
+
         this.baseUrl = baseUrl;
     }
 
+    /** @type {Map<string, import("../spec/root.js").NamedGenomeConfig>} */
+    #configuredGenomesByName;
+
+    /** @type {Map<string, Promise<void>>} */
+    #loadingPromisesByName;
+
+    /** @type {Map<string, string>} */
+    #inlineAssemblyNamesByKey;
+
+    /** @type {number} */
+    #nextInlineAssemblyIndex;
+
+    /** @type {string | undefined} */
+    #defaultAssemblyName;
+
     /**
      * @param {import("../spec/genome.js").GenomeConfig} genomeConfig
      */
-    // eslint-disable-next-line require-await
     async initialize(genomeConfig) {
-        const genome = new Genome(genomeConfig);
-        this.genomes.set(genome.name, genome);
+        const { name, ...config } = genomeConfig;
+        this.configureGenomes(new Map([[name, config]]), name);
+        await this.ensureAssembly(name);
+    }
 
-        return Promise.all(
-            [...this.genomes.values()].map((genome) =>
-                genome.load(this.baseUrl)
-            )
-        );
+    /**
+     * @param {Map<string, import("../spec/root.js").NamedGenomeConfig>} genomesByName
+     * @param {string} [defaultAssembly]
+     */
+    configureGenomes(genomesByName, defaultAssembly) {
+        this.genomes.clear();
+        this.#loadingPromisesByName.clear();
+        this.#inlineAssemblyNamesByKey.clear();
+        this.#nextInlineAssemblyIndex = 0;
+        this.#configuredGenomesByName = new Map(genomesByName);
+        this.#defaultAssemblyName = defaultAssembly;
+    }
+
+    /**
+     * @returns {string | undefined}
+     */
+    getDefaultAssemblyName() {
+        if (this.#defaultAssemblyName) {
+            return this.#defaultAssemblyName;
+        }
+
+        if (this.#configuredGenomesByName.size === 1) {
+            return this.#configuredGenomesByName.keys().next().value;
+        }
+
+        if (
+            this.#configuredGenomesByName.size === 0 &&
+            this.genomes.size === 1
+        ) {
+            return this.genomes.keys().next().value;
+        }
+
+        return undefined;
     }
 
     /**
-     * @param {string} [name] If not given, a default genome is returned.
+     * @param {(string | import("../spec/scale.js").InlineLocusAssembly | undefined)[]} assemblies
+     */
+    async ensureAssemblies(assemblies) {
+        /** @type {Promise<Genome>[]} */
+        const pending = [];
+        /** @type {Set<string>} */
+        const seenAssemblies = new Set();
+
+        for (const assembly of assemblies) {
+            if (!assembly) {
+                continue;
+            }
+
+            const dedupKey = getAssemblyDedupKey(assembly);
+            if (seenAssemblies.has(dedupKey)) {
+                continue;
+            }
+
+            seenAssemblies.add(dedupKey);
+            pending.push(this.ensureAssembly(assembly));
+        }
+
+        await Promise.all(pending);
+    }
+
+    /**
+     * @param {string | import("../spec/scale.js").InlineLocusAssembly} assembly
+     * @returns {Promise<Genome>}
+     */
+    async ensureAssembly(assembly) {
+        if (typeof assembly === "object") {
+            return this.#ensureInlineAssemblyGenome(assembly);
+        }
+
+        const existing = this.genomes.get(assembly);
+        if (existing) {
+            return existing;
+        }
+
+        const configured = this.#configuredGenomesByName.get(assembly);
+        if (configured) {
+            return this.#ensureConfiguredGenome(assembly, configured);
+        }
+
+        const builtIn = this.#getOrCreateBuiltInGenome(assembly);
+        if (builtIn) {
+            return builtIn;
+        }
+
+        throw this.#createUnknownGenomeError(assembly);
+    }
+
+    /**
+     * @param {string | import("../spec/scale.js").InlineLocusAssembly} [name] If not given, a default genome is returned.
      * @returns {Genome}
      */
     getGenome(name) {
-        if (!this.genomes.size) {
-            throw new Error("No genomes have been configured!");
+        if (name && typeof name == "object") {
+            return this.#getInlineAssemblyGenome(name);
         }
 
-        if (name) {
+        if (typeof name === "string") {
             const genome = this.genomes.get(name);
-            if (!genome) {
+            if (genome) {
+                return genome;
+            }
+
+            if (this.#configuredGenomesByName.has(name)) {
                 throw new Error(
-                    `No genome with the name ${name} has been configured!`
+                    `Genome ${name} has not been loaded yet. Call ensureAssembly("${name}") before accessing it.`
                 );
             }
+
+            const builtIn = this.#getOrCreateBuiltInGenome(name);
+            if (builtIn) {
+                return builtIn;
+            }
+
+            throw this.#createUnknownGenomeError(name);
+        }
+
+        const defaultAssemblyName = this.getDefaultAssemblyName();
+        if (defaultAssemblyName) {
+            return this.getGenome(defaultAssemblyName);
+        }
+
+        if (this.#configuredGenomesByName.size > 1) {
+            throw new Error(
+                "Cannot pick a default genome! More than one have been configured!"
+            );
+        }
+
+        if (this.genomes.size === 0 && this.#configuredGenomesByName.size) {
+            throw new Error(
+                "Default genome is not loaded. Define root `assembly` or call ensureAssembly() first."
+            );
+        }
+
+        if (this.genomes.size > 1) {
+            throw new Error(
+                "Cannot pick a default genome! More than one have been configured!"
+            );
+        }
+
+        if (this.genomes.size === 0) {
+            throw new Error("No genomes have been configured!");
+        }
+
+        return this.genomes.values().next().value;
+    }
+
+    /**
+     * @param {string} name
+     * @returns {Genome | undefined}
+     */
+    #tryCreateBuiltInGenome(name) {
+        try {
+            return new Genome({ name });
+        } catch (_error) {
+            return undefined;
+        }
+    }
+
+    /**
+     * @param {string} name
+     * @returns {Error}
+     */
+    #createUnknownGenomeError(name) {
+        return new Error(
+            `No genome with the name ${name} has been configured!`
+        );
+    }
+
+    /**
+     * @param {string} name
+     * @returns {Genome | undefined}
+     */
+    #getOrCreateBuiltInGenome(name) {
+        const builtIn = this.#tryCreateBuiltInGenome(name);
+        if (builtIn) {
+            this.genomes.set(name, builtIn);
+            return builtIn;
+        }
+
+        return undefined;
+    }
+
+    /**
+     * @param {string} name
+     * @param {string} missingGenomeError
+     * @returns {Promise<Genome>}
+     */
+    async #awaitLoadedGenomeFromPending(name, missingGenomeError) {
+        const pending = this.#loadingPromisesByName.get(name);
+        if (!pending) {
+            throw new Error(`No pending genome load for ${name}.`);
+        }
+
+        await pending;
+        const loaded = this.genomes.get(name);
+        if (!loaded) {
+            throw new Error(missingGenomeError);
+        }
+
+        return loaded;
+    }
+
+    /**
+     * @param {string} name
+     * @param {Genome} genome
+     * @returns {Promise<Genome>}
+     */
+    async #loadGenome(name, genome) {
+        const loadPromise = genome.load(this.baseUrl);
+        this.#loadingPromisesByName.set(name, loadPromise);
+
+        try {
+            await loadPromise;
+        } catch (error) {
+            this.genomes.delete(name);
+            throw error;
+        } finally {
+            this.#loadingPromisesByName.delete(name);
+        }
+
+        return genome;
+    }
+
+    /**
+     * @param {string} name
+     * @param {import("../spec/root.js").NamedGenomeConfig} config
+     * @returns {Promise<Genome>}
+     */
+    async #ensureConfiguredGenome(name, config) {
+        const existing = this.genomes.get(name);
+        if (existing) {
+            if (this.#loadingPromisesByName.has(name)) {
+                return this.#awaitLoadedGenomeFromPending(
+                    name,
+                    `Loading genome ${name} failed before it became available.`
+                );
+            }
+            return existing;
+        }
+
+        if (this.#loadingPromisesByName.has(name)) {
+            return this.#awaitLoadedGenomeFromPending(
+                name,
+                `Loading genome ${name} failed before it became available.`
+            );
+        }
+
+        const genome = new Genome({
+            name,
+            ...config,
+        });
+        this.genomes.set(name, genome);
+
+        if ("url" in config) {
+            return this.#loadGenome(name, genome);
+        }
+
+        return genome;
+    }
+
+    /**
+     * @param {import("../spec/scale.js").InlineLocusAssembly} assembly
+     * @returns {Promise<Genome>}
+     */
+    async #ensureInlineAssemblyGenome(assembly) {
+        this.#validateInlineAssembly(assembly);
+
+        const inlineName = this.#resolveInlineAssemblyName(assembly);
+
+        const existing = this.genomes.get(inlineName);
+        if (existing) {
+            if (this.#loadingPromisesByName.has(inlineName)) {
+                return this.#awaitLoadedGenomeFromPending(
+                    inlineName,
+                    `Loading inline assembly ${inlineName} failed before it became available.`
+                );
+            }
+            return existing;
+        }
+
+        if (this.#loadingPromisesByName.has(inlineName)) {
+            return this.#awaitLoadedGenomeFromPending(
+                inlineName,
+                `Loading inline assembly ${inlineName} failed before it became available.`
+            );
+        }
+
+        if ("contigs" in assembly) {
+            const genome = new Genome({
+                name: inlineName,
+                contigs: assembly.contigs,
+            });
+            this.genomes.set(inlineName, genome);
             return genome;
-        } else {
-            if (this.genomes.size > 1) {
+        }
+
+        const genome = new Genome({
+            name: inlineName,
+            url: assembly.url,
+        });
+        this.genomes.set(inlineName, genome);
+
+        return this.#loadGenome(inlineName, genome);
+    }
+
+    /**
+     * @param {import("../spec/scale.js").InlineLocusAssembly} assembly
+     * @returns {Genome}
+     */
+    #getInlineAssemblyGenome(assembly) {
+        this.#validateInlineAssembly(assembly);
+
+        const inlineName = this.#resolveInlineAssemblyName(assembly);
+        const existing = this.genomes.get(inlineName);
+        if (existing) {
+            if (this.#loadingPromisesByName.has(inlineName)) {
                 throw new Error(
-                    "Cannot pick a default genome! More than one have been configured!"
+                    `Inline URL assembly ${inlineName} has not been loaded yet. Call ensureAssembly() before accessing it.`
                 );
             }
-            return this.genomes.values().next().value;
+            return existing;
+        }
+
+        if ("url" in assembly) {
+            throw new Error(
+                "Inline URL assemblies must be loaded first. Call ensureAssembly() before accessing it."
+            );
         }
+
+        const genome = new Genome({
+            name: inlineName,
+            contigs: assembly.contigs,
+        });
+        this.genomes.set(inlineName, genome);
+
+        return genome;
+    }
+
+    /**
+     * @param {import("../spec/scale.js").InlineLocusAssembly} assembly
+     */
+    #validateInlineAssembly(assembly) {
+        const hasContigs = "contigs" in assembly;
+        const hasUrl = "url" in assembly;
+        if (hasContigs === hasUrl) {
+            throw new Error(
+                "Inline `scale.assembly` objects must define exactly one of `contigs` or `url`."
+            );
+        }
+    }
+
+    /**
+     * @param {import("../spec/scale.js").InlineLocusAssembly} assembly
+     * @returns {string}
+     */
+    #resolveInlineAssemblyName(assembly) {
+        const key = JSON.stringify(assembly);
+        const existingName = this.#inlineAssemblyNamesByKey.get(key);
+        if (existingName) {
+            return existingName;
+        }
+
+        let candidate = `inline_assembly_${this.#nextInlineAssemblyIndex}`;
+        this.#nextInlineAssemblyIndex += 1;
+        while (
+            this.genomes.has(candidate) ||
+            this.#configuredGenomesByName.has(candidate) ||
+            this.#loadingPromisesByName.has(candidate)
+        ) {
+            candidate = `inline_assembly_${this.#nextInlineAssemblyIndex}`;
+            this.#nextInlineAssemblyIndex += 1;
+        }
+
+        this.#inlineAssemblyNamesByKey.set(key, candidate);
+        return candidate;
     }
 }
+
+/**
+ * @param {string | import("../spec/scale.js").InlineLocusAssembly} assembly
+ * @returns {string}
+ */
+function getAssemblyDedupKey(assembly) {
+    if (typeof assembly === "string") {
+        return `name:${assembly}`;
+    }
+
+    return `inline:${JSON.stringify(assembly)}`;
+}

package/dist/src/genome/rootGenomeConfig.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @typedef {import("../spec/root.js").RootConfig} RootConfig
+ * @typedef {import("../spec/root.js").NamedGenomeConfig} NamedGenomeDefinition
+ */
+/**
+ * @typedef {object} ResolvedRootGenomeConfig
+ * @prop {Map<string, NamedGenomeDefinition>} genomesByName
+ * @prop {string | undefined} defaultAssembly
+ * @prop {string | undefined} deprecationWarning
+ */
+/**
+ * Resolves root-level genome configuration into a canonical map and default
+ * assembly name.
+ *
+ * @param {RootConfig} rootConfig
+ * @returns {ResolvedRootGenomeConfig}
+ */
+export function resolveRootGenomeConfig(rootConfig: RootConfig): ResolvedRootGenomeConfig;
+export type RootConfig = import("../spec/root.js").RootConfig;
+export type NamedGenomeDefinition = import("../spec/root.js").NamedGenomeConfig;
+export type ResolvedRootGenomeConfig = {
+    genomesByName: Map<string, NamedGenomeDefinition>;
+    defaultAssembly: string | undefined;
+    deprecationWarning: string | undefined;
+};
+//# sourceMappingURL=rootGenomeConfig.d.ts.map

package/dist/src/genome/rootGenomeConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rootGenomeConfig.d.ts","sourceRoot":"","sources":["../../../src/genome/rootGenomeConfig.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;;;;;GAKG;AAEH;;;;;;GAMG;AACH,oDAHW,UAAU,GACR,wBAAwB,CAkDpC;yBAlEY,OAAO,iBAAiB,EAAE,UAAU;oCACpC,OAAO,iBAAiB,EAAE,iBAAiB;;mBAK9C,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC;qBAClC,MAAM,GAAG,SAAS;wBAClB,MAAM,GAAG,SAAS"}

package/dist/src/genome/rootGenomeConfig.js

@@ -0,0 +1,94 @@
+import { getContigs } from "./genomes.js";
+
+/**
+ * @typedef {import("../spec/root.js").RootConfig} RootConfig
+ * @typedef {import("../spec/root.js").NamedGenomeConfig} NamedGenomeDefinition
+ */
+
+/**
+ * @typedef {object} ResolvedRootGenomeConfig
+ * @prop {Map<string, NamedGenomeDefinition>} genomesByName
+ * @prop {string | undefined} defaultAssembly
+ * @prop {string | undefined} deprecationWarning
+ */
+
+/**
+ * Resolves root-level genome configuration into a canonical map and default
+ * assembly name.
+ *
+ * @param {RootConfig} rootConfig
+ * @returns {ResolvedRootGenomeConfig}
+ */
+export function resolveRootGenomeConfig(rootConfig) {
+    if (rootConfig.genome && rootConfig.genomes) {
+        throw new Error(
+            "Do not mix deprecated `genome` with `genomes`. Use only `genomes` and `assembly`."
+        );
+    }
+
+    if (rootConfig.genome && rootConfig.assembly) {
+        throw new Error(
+            "Do not mix deprecated `genome` with root `assembly`. Use `genomes` and `assembly`."
+        );
+    }
+
+    if (rootConfig.genome) {
+        const { name, ...config } = rootConfig.genome;
+        return {
+            genomesByName: new Map([[name, config]]),
+            defaultAssembly: name,
+            deprecationWarning: getLegacyGenomeWarning(),
+        };
+    }
+
+    /** @type {Map<string, NamedGenomeDefinition>} */
+    const genomesByName = new Map();
+    for (const [name, config] of Object.entries(rootConfig.genomes ?? {})) {
+        genomesByName.set(name, config ?? {});
+    }
+
+    let defaultAssembly = rootConfig.assembly;
+    if (!defaultAssembly && genomesByName.size === 1) {
+        defaultAssembly = genomesByName.keys().next().value;
+    }
+
+    if (
+        defaultAssembly &&
+        !genomesByName.has(defaultAssembly) &&
+        !isBuiltInAssembly(defaultAssembly)
+    ) {
+        throw new Error(
+            `Root assembly "${defaultAssembly}" is neither defined in \`genomes\` nor a built-in assembly.`
+        );
+    }
+
+    return {
+        genomesByName,
+        defaultAssembly,
+        deprecationWarning: undefined,
+    };
+}
+
+/**
+ * @returns {string}
+ */
+function getLegacyGenomeWarning() {
+    return (
+        "Root `genome` is deprecated and will be removed in a future version. " +
+        "Use root `genomes` and `assembly` instead. Built-in migration example: " +
+        '{"genome":{"name":"hg38"}} -> {"assembly":"hg38"}.'
+    );
+}
+
+/**
+ * @param {string} name
+ * @returns {boolean}
+ */
+function isBuiltInAssembly(name) {
+    try {
+        getContigs(name);
+        return true;
+    } catch (_error) {
+        return false;
+    }
+}

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

@@ -25,7 +25,7 @@ export default class InteractionController {
         datum: import("../data/flowNode.js").Datum;
         uniqueId: number;
     };
-    registerMouseEvents(): void;
+    registerInteractionEvents(): void;
     /**
      * This method should be called in a mouseMove handler. If not called, the
      * tooltip will be hidden.
@@ -37,4 +37,8 @@ export default class InteractionController {
     updateTooltip<T>(datum: T, converter?: (arg0: T) => Promise<string | HTMLElement | import("lit").TemplateResult>): void;
     #private;
 }
+export type ClientPointLike = {
+    clientX: number;
+    clientY: number;
+};
 //# sourceMappingURL=interactionController.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"interactionController.d.ts","sourceRoot":"","sources":["../../../src/genomeSpy/interactionController.js"],"names":[],"mappings":"AASA;IA2BI;;;;;;;;;;OAUG;IACH,mIATG;QAAmD,QAAQ,EAAnD,OAAO,iBAAiB,EAAE,OAAO;QACe,QAAQ,EAAxD,OAAO,sBAAsB,EAAE,OAAO;QACY,OAAO,EAAzD,OAAO,wBAAwB,EAAE,OAAO;QACQ,QAAQ,EAAxD,OAAO,sBAAsB,EAAE,OAAO;QACM,SAAS,EAArD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI;QAC6C,eAAe,EAA9F,MAAM,CAAC,MAAM,EAAE,OAAO,8BAA8B,EAAE,cAAc,CAAC;QACjD,wBAAwB,EAA5C,MAAM,IAAI;QACY,mBAAmB,EAAzC,MAAM,MAAM;KACtB,EAgCA;IAED;cArDkB,OAAO,kBAAkB,EAAE,OAAO;eAAS,OAAO,qBAAqB,EAAE,KAAK;kBAAY,MAAM;MAuDjH;IAED,4BAgMC;IAkFD;;;;;;;OAOG;IACH,cAFa,CAAC,SAFH,CAAC,cACD,CAAS,IAAC,EAAD,CAAC,KAAE,OAAO,CAAC,MAAM,GAAG,WAAW,GAAG,OAAO,KAAK,EAAE,cAAc,CAAC,QAYlF;;CACJ"}
+{"version":3,"file":"interactionController.d.ts","sourceRoot":"","sources":["../../../src/genomeSpy/interactionController.js"],"names":[],"mappings":"AASA;IA2BI;;;;;;;;;;OAUG;IACH,mIATG;QAAmD,QAAQ,EAAnD,OAAO,iBAAiB,EAAE,OAAO;QACe,QAAQ,EAAxD,OAAO,sBAAsB,EAAE,OAAO;QACY,OAAO,EAAzD,OAAO,wBAAwB,EAAE,OAAO;QACQ,QAAQ,EAAxD,OAAO,sBAAsB,EAAE,OAAO;QACM,SAAS,EAArD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI;QAC6C,eAAe,EAA9F,MAAM,CAAC,MAAM,EAAE,OAAO,8BAA8B,EAAE,cAAc,CAAC;QACjD,wBAAwB,EAA5C,MAAM,IAAI;QACY,mBAAmB,EAAzC,MAAM,MAAM;KACtB,EAgCA;IAED;cArDkB,OAAO,kBAAkB,EAAE,OAAO;eAAS,OAAO,qBAAqB,EAAE,KAAK;kBAAY,MAAM;MAuDjH;IAED,kCAwXC;IAkFD;;;;;;;OAOG;IACH,cAFa,CAAC,SAFH,CAAC,cACD,CAAS,IAAC,EAAD,CAAC,KAAE,OAAO,CAAC,MAAM,GAAG,WAAW,GAAG,OAAO,KAAK,EAAE,cAAc,CAAC,QAYlF;;CACJ;8BAGY;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC"}