higlass 1.13.5 → 2.0.0

package/dist/app/scripts/utils/dec-to-hex-str.d.ts

@@ -0,0 +1,8 @@
+export default decToHexStr;
+/**
+ * Converts a decimal number to a hex string.
+ *
+ * @param {number} dec - Decimal number
+ * @return {string} Hex string
+ */
+declare function decToHexStr(dec: number): string;

package/dist/app/scripts/utils/decompress.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Decompress a compressed data source.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/DecompressionStream DecompressionStream API}
+ *
+ * @example
+ * ```typescript
+ * const compressed = new Uint8Array([
+ *   0x1f, 0x8b, 0x08, 0x00, 0x1e, 0xc0, 0x7e, 0x67, 0x00, 0x03, 0xf3, 0x48,
+ *   0xcd, 0xc9, 0xc9, 0xd7, 0x51, 0x28, 0xcf, 0x2f, 0xca, 0x49, 0x51, 0x04,
+ *   0x00, 0xe6, 0xc6, 0xe6, 0xeb, 0x0d, 0x00, 0x00, 0x00
+ * ]);
+ * console.log(await decompress(compressed, { format: "gzip" }).text()); // "Hello, world!"
+ * ```
+ *
+ * @param {BodyInit | Response} data - The compressed data.
+ * @param {Object} options
+ * @param {CompressionFormat} options.format
+ * @param {AbortSignal=} options.signal
+ * @returns {Response} A new response for decompressed data.
+ *
+ * @see {@link https://github.com/manzt/manzt/blob/1380bb/utils/decompress.js source}
+ */
+export default function decompress(data: BodyInit | Response, options: {
+    format: CompressionFormat;
+    signal?: AbortSignal | undefined;
+}): Response;

package/dist/app/scripts/utils/default-tracks.d.ts

@@ -0,0 +1,3 @@
+/** Get the default tracks for a datatype. Uses the known track definitions as
+ * well as any extra definitions that may be passed in. */
+export default function getDefaultTracksForDatatype(datatype: any, otherDefaultTracks: any): any;

package/dist/app/scripts/utils/dict-from-tuples.d.ts

@@ -0,0 +1,11 @@
+export default dictFromTuples;
+/**
+ * Create a dictionary from a list of [key, value] pairs.
+ *
+ * TODO(Trevor): Replace with Object.fromEntries?
+ *
+ * @template {ReadonlyArray<readonly [PropertyKey, unknown]>} T
+ * @param {T} tuples: A list of [key, value] pairs
+ * @return {{ [Item in T[number] as Item[0]]: Item[1] }} A dictionary
+ */
+declare function dictFromTuples<T extends ReadonlyArray<readonly [PropertyKey, unknown]>>(tuples: T): { [Item in T[number] as Item[0]]: Item[1]; };

package/dist/app/scripts/utils/dict-items.d.ts

@@ -0,0 +1,18 @@
+export default dictItems;
+export type DictItems<T> = Array<{ [Key in keyof T]: [Key, T[Key]]; }[keyof T]>;
+/**
+ * @template T
+ * @typedef {Array<{ [Key in keyof T]: [Key, T[Key]] }[keyof T]>} DictItems
+ */
+/**
+ * Return an array of (key,value) pairs that are present in this
+ * dictionary
+ *
+ * TODO(Trevor): Replace with `Object.entries`?
+ *
+ * @template {object} T
+ * @param {T} dictionary
+ *
+ * @returns {DictItems<T>}
+ */
+declare function dictItems<T extends object>(dictionary: T): DictItems<T>;

package/dist/app/scripts/utils/dict-keys.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Return an array of keys that are present in this dictionary
+ *
+ * TODO(Trevor): Replace with `Object.keys`?
+ *
+ * @template T
+ * @param {T} dictionary
+ * @returns {Array<keyof T>}
+ */
+export default function dictKeys<T>(dictionary: T): Array<keyof T>;

package/dist/app/scripts/utils/dict-values.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Return an array of values that are present in this dictionary
+ *
+ * @template {object} T
+ * @param {T} dictionary
+ * @returns {Array<T[keyof T]>}
+ */
+export default function dictValues<T extends object>(dictionary: T): Array<T[keyof T]>;

package/dist/app/scripts/utils/download.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Download a file to the user's computer.
+ * @param {string} filename - Name of the file to download
+ * @param {string | Blob} stringOrBlob - Contents of the file to download
+ */
+export function download(filename: string, stringOrBlob: string | Blob): void;
+export default download;

package/dist/app/scripts/utils/expand-combined-tracks.d.ts

@@ -0,0 +1,11 @@
+export default expandCombinedTracks;
+/** @import * as t from '../types' */
+/**
+ * Go through a list of tracks and expand combined
+ * tracks.
+ *
+ * @param {Array<t.TrackConfig>} trackList - A list of tracks some of which might be combined
+ * @returns {Array<t.UnknownTrackConfig>} A list of tracks without combined
+ */
+declare function expandCombinedTracks(trackList: Array<t.TrackConfig>): Array<t.UnknownTrackConfig>;
+import type * as t from '../types';

package/dist/app/scripts/utils/fake-pub-sub.d.ts

@@ -0,0 +1,11 @@
+export default fakePubSub;
+declare namespace fakePubSub {
+    let __fake__: boolean;
+    function publish(): void;
+    function subscribe(): {
+        event: string;
+        handler: () => void;
+    };
+    function unsubscribe(): void;
+    function clear(): void;
+}

package/dist/app/scripts/utils/fill-in-min-widths.d.ts

@@ -0,0 +1,44 @@
+export default fillInMinWidths;
+export type CompleteTracks = {
+    center: Array<t.TrackConfig>;
+    left: Array<t.TrackConfig>;
+    right: Array<t.TrackConfig>;
+    top: Array<t.TrackConfig>;
+    bottom: Array<t.TrackConfig>;
+    whole: Array<t.TrackConfig>;
+    gallery: Array<t.TrackConfig>;
+};
+export type WithMinWidth<K extends t.TrackPosition, T extends Array<t.TrackConfig>> = Array<T[number] & {
+    width: number;
+}>;
+/** @import * as t from '../types' */
+/**
+ * @typedef CompleteTracks
+ * @property {Array<t.TrackConfig>} center
+ * @property {Array<t.TrackConfig>} left
+ * @property {Array<t.TrackConfig>} right
+ * @property {Array<t.TrackConfig>} top
+ * @property {Array<t.TrackConfig>} bottom
+ * @property {Array<t.TrackConfig>} whole
+ * @property {Array<t.TrackConfig>} gallery
+ */
+/**
+ * @template {t.TrackPosition} K
+ * @template {Array<t.TrackConfig>} T
+ * @typedef {Array<T[number] & { width: number }>} WithMinWidth
+ */
+/**
+ * If tracks don't have specified dimensions, add in the known minimums
+ *
+ * WARNING: Mutates `tracks` argument
+ *
+ * @template {Partial<CompleteTracks>} T
+ * @param {T} tracks
+ * @returns {{
+ *  [K in t.TrackPosition]: K extends keyof T ? T[K] extends undefined ? Array<t.TrackConfig> : T[K] : Array<t.TrackConfig>
+ * }}
+ *
+ * Operates on the tracks stored for this TiledPlot.
+ */
+declare function fillInMinWidths<T extends Partial<CompleteTracks>>(tracks: T): { [K in t.TrackPosition]: K extends keyof T ? T[K] extends undefined ? Array<t.TrackConfig> : T[K] : Array<t.TrackConfig>; };
+import type * as t from '../types';

package/dist/app/scripts/utils/flatten.d.ts

@@ -0,0 +1,9 @@
+export default flatten;
+/**
+ * Function for flattening a nested array. It returns a curried reducer.
+ *
+ * @template T
+ * @param {Array<Array<T>>} Nested array
+ * @return {Array<T>} Flat array
+ */
+declare const flatten: (x: any[]) => never[];

package/dist/app/scripts/utils/for-each.d.ts

@@ -0,0 +1,9 @@
+export default forEach;
+/**
+ * Functional version of `Array.forEach`. More flexible and applicable to other array-like data types.
+ *
+ * @template T
+ * @param {<T>(item: T) => void} f - Modifier function applied on every item of the array.
+ * @return {(arr: ArrayLike<T>) => void} Modified array-like variable.
+ */
+declare function forEach<T>(f: <T_1>(item: T_1) => void): (arr: ArrayLike<T>) => void;

package/dist/app/scripts/utils/forward-event.d.ts

@@ -0,0 +1,7 @@
+export default forwardEvent;
+/**
+ * Forward an event by cloning and dispatching it.
+ * @param {Event} event - Event to be forwarded.
+ * @param {HTMLElement} target - Target HTML element for the event.
+ */
+declare function forwardEvent(event: Event, target: HTMLElement): void;

package/dist/app/scripts/utils/genome-loci-to-pixels.d.ts

@@ -0,0 +1,9 @@
+export default genomeLociToPixels;
+/**
+ * Convert a genome locus to an absolute genome position.
+ * @template {string} Name
+ * @param {[Name, number, Name, number]} genomeLoci - Genome locus
+ * @param {import('../types').ChromInfo<Name>} chromInfo - Chromosome info object
+ * @return {[start: number, end: number]} The absolute genome position.
+ */
+declare function genomeLociToPixels<Name extends string>(genomeLoci: [Name, number, Name, number], chromInfo: import("../types").ChromInfo<Name>): [start: number, end: number];

package/dist/app/scripts/utils/genomic-range-to-chromosome-chunks.d.ts

@@ -0,0 +1,21 @@
+export default genomicRangeToChromosomeChunks;
+/**
+ * Using the [genomicStart, genomicEnd] range, get an array of "chromosome chunks",
+ * where each chunk range starts and ends with the same chromosome.
+ * Start a new chromosome chunk at each chromosome boundary.
+ *
+ * @template {string} Name
+ * @param {Array<[charName: Name, chrLen: number]>} chromSizes - Array of [chrName, chrLen] tuples.
+ * @param {{ chr: Name, pos: number }} genomicStart - A genomic position object returned from abs2genomic { chr, pos }.
+ * @param {{ chr: Name, pos: number }} genomicEnd - A genomic position object returned from abs2genomic { chr, pos }.
+ * @param {number} binSize - The resolution / bin size.
+ * @param {number} tileSize - The tile size (probably 256).
+ * @returns {Array<[chrName: Name, zStart: number, zEnd: number]>} Returns array of [chrName, zStart, zEnd] tuples.
+ */
+declare function genomicRangeToChromosomeChunks<Name extends string>(chromSizes: Array<[charName: Name, chrLen: number]>, genomicStart: {
+    chr: Name;
+    pos: number;
+}, genomicEnd: {
+    chr: Name;
+    pos: number;
+}, binSize: number, tileSize: number): Array<[chrName: Name, zStart: number, zEnd: number]>;

package/dist/app/scripts/utils/get-aggregation-function.d.ts

@@ -0,0 +1,10 @@
+export default getAggregationFunction;
+export type Aggregation = (values: number[]) => number | undefined;
+/** @typedef {(values: number[]) => number | undefined} Aggregation */
+/**
+ * Get an aggregation function from a function name.
+ * @param {'mean' | 'sum' | 'variance' | 'deviation'} name - The type of aggregation.
+ * If an unknown string is passed, the mean function will be used (and a warning will be logged).
+ * @returns {Aggregation} The function of interest as determined by the string,
+ */
+declare function getAggregationFunction(name: "mean" | "sum" | "variance" | "deviation"): Aggregation;

package/dist/app/scripts/utils/get-default-track-for-datatype.d.ts

@@ -0,0 +1,21 @@
+export default getDefaultTrackForDatatype;
+export type DataTypeMapping = typeof DEFAULT_TRACKS_FOR_DATATYPE;
+export type DataType = keyof DataTypeMapping;
+export type TrackPosition = "top" | "bottom" | "left" | "right" | "center";
+export type ExtractDataType<D extends string, P extends string> = D extends DataType ? P extends keyof DataTypeMapping[D] ? DataTypeMapping[D][P] : undefined : undefined;
+/**
+ * Gets the default track as defined in utils/default-tracks-for-datatype.js
+ *
+ * @template {DataType | string & {}} D
+ * @template {TrackPosition} P
+ * @template {ReadonlyArray<{ type: string }>} ATracks
+ *
+ * @param  {D} datatype - The datatype to get the default track for
+ * @param  {P} position - top, bottom, left, right, center
+ * @param  {ATracks} availableTracks - List of tracks to choose from, typically obtained from AVAILABLE_TRACK_TYPES(...)
+ * @return {ATracks[number] | undefined} An element of availableTracks or undefined
+ */
+declare function getDefaultTrackForDatatype<D extends DataType | (string & {}), P extends TrackPosition, ATracks extends ReadonlyArray<{
+    type: string;
+}>>(datatype: D, position: P, availableTracks: ATracks): ATracks[number] | undefined;
+import { DEFAULT_TRACKS_FOR_DATATYPE } from '../configs';

package/dist/app/scripts/utils/get-default-tracks-for-datatype.d.ts

@@ -0,0 +1,3 @@
+/** Get the default tracks for a datatype. Uses the known track definitions as
+ * well as any extra definitions that may be passed in. */
+export default function getDefaultTracksForDatatype(datatype: any, otherDefaultTracks: any): any;

package/dist/app/scripts/utils/get-element-dim.d.ts

@@ -0,0 +1,7 @@
+export default getElementDim;
+/**
+ * Get the dimensions of an element
+ * @param {HTMLElement} element - DOM element to get dimensions of.
+ * @return {[width: number, height: number]} The width and height of the element.
+ */
+declare function getElementDim(element: HTMLElement): [width: number, height: number];

package/dist/app/scripts/utils/get-higlass-components.d.ts

@@ -0,0 +1,7 @@
+export function getTrackObjectFromHGC(hgc: HiGlassComponent, viewUid: string, trackUid: string | undefined): t.TrackObject | undefined;
+export function getTrackRenderer(hgc: HiGlassComponent, viewUid: string): TrackRenderer | null;
+export function getTiledPlot(hgc: HiGlassComponent, viewUid: string): TiledPlot;
+import type HiGlassComponent from '../HiGlassComponent';
+import type * as t from '../types';
+import type { TrackRenderer } from '../TrackRenderer';
+import type { TiledPlot } from '../TiledPlot';

package/dist/app/scripts/utils/get-track-by-uid.d.ts

@@ -0,0 +1,7 @@
+export default getTrackByUid;
+/**
+ * Return the track object for the track corresponding to this uid
+ *
+ * Null or undefined if none.
+ */
+declare function getTrackByUid(tracks: any, uid: any): null;

package/dist/app/scripts/utils/get-track-conf-from-hgc.d.ts

@@ -0,0 +1,10 @@
+export default getTrackConfFromHGC;
+/**
+ * Get a track's config (not the track object) from a higlass component.
+ *
+ * @param  {HiGlassComponent} hgc      HiGlassComponent object
+ * @param  {string} viewUid  The uid of the view
+ * @param  {string} trackUid The uid of the track
+ * @return {object}          Track conf if found else null
+ */
+declare function getTrackConfFromHGC(hgc: HiGlassComponent, viewUid: string, trackUid: string): object;

package/dist/app/scripts/utils/get-track-obj-by-id.d.ts

@@ -0,0 +1,2 @@
+export default getTrackObjById;
+declare function getTrackObjById(tiledPlots: any, viewId: any, trackId: any): any;

package/dist/app/scripts/utils/get-track-position-by-uid.d.ts

@@ -0,0 +1,13 @@
+export default getTrackPositionByUid;
+/** @import { TrackPosition } from '../types' */
+/** @import { PositionedTracks } from './visit-positioned-tracks' */
+/**
+ * Get a track's orientation by its UID.
+ *
+ * @param {PositionedTracks} positionedTracks
+ * @param {string} uid
+ * @returns {TrackPosition | null}
+ */
+declare function getTrackPositionByUid(positionedTracks: PositionedTracks, uid: string): TrackPosition | null;
+import type { PositionedTracks } from './visit-positioned-tracks';
+import type { TrackPosition } from '../types';

package/dist/app/scripts/utils/get-xylofon.d.ts

@@ -0,0 +1,2 @@
+export default getXylofon;
+declare function getXylofon(): readonly [Window & typeof globalThis, string];

package/dist/app/scripts/utils/gradient.d.ts

@@ -0,0 +1,14 @@
+export default gradient;
+/**
+ * @param {{ from: number, color: string }[]} steps
+ * @param {number} width
+ * @param {number} height
+ * @param {number} fromX
+ * @param {number} fromY
+ * @param {number} toX
+ * @param {number} toY
+ */
+declare function gradient(steps: {
+    from: number;
+    color: string;
+}[], width?: number, height?: number, fromX?: number, fromY?: number, toX?: number, toY?: number): HTMLCanvasElement;

package/dist/app/scripts/utils/has-class.d.ts

@@ -0,0 +1,8 @@
+export default hasClass;
+/**
+ * Check if an HTML or SVG element has a certain class
+ * @param {Element} el - HTML or SVG element to be checked.
+ * @param {string} className - Class name to be checked for.
+ * @return {boolean} If `true` `el` has the class name.
+ */
+declare function hasClass(el: Element, className: string): boolean;

package/dist/app/scripts/utils/has-parent.d.ts

@@ -0,0 +1,9 @@
+export default hasParent;
+/**
+ * Test whether a DOM element is the parent of another DOM element.
+ *
+ * @param {HTMLElement} el - Potential child element.
+ * @param {HTMLElement} target - Target parent element which is tested to have `el` as a child.
+ * @return {boolean}  If `true` `el` has `target` as a parent.
+ */
+declare function hasParent(el: HTMLElement, target: HTMLElement): boolean;

package/dist/app/scripts/utils/hex-string-to-int.d.ts

@@ -0,0 +1,14 @@
+export default hexStrToInt;
+/**
+ * Convert a HEX string into a HEX integer.
+ *
+ * @example
+ * ```js
+ * // returns 16711680
+ * hexStrToInt("#FF0000");
+ * ```
+ *
+ * @param {string} str - HEX string
+ * @return {number} An (integer) HEX number
+ */
+declare function hexStrToInt(str: string): number;

package/dist/app/scripts/utils/index.d.ts

@@ -0,0 +1,89 @@
+export { default as absToChr } from "./abs-to-chr";
+export { default as accessorTransposition } from "./accessor-transposition";
+export { default as addArrays } from "./add-arrays";
+export { default as addClass } from "./add-class";
+export { default as base64ToCanvas } from "./base64-to-canvas";
+export { default as chromInfoBisector } from "./chrom-info-bisector";
+export { default as chrToAbs } from "./chr-to-abs";
+export { default as cloneEvent } from "./clone-event";
+export { default as colorDomainToRgbaArray } from "./color-domain-to-rgba-array";
+export { default as colorToHex } from "./color-to-hex";
+export { default as colorToRgba } from "./color-to-rgba";
+export { default as dataToGenomicLoci } from "./data-to-genomic-loci";
+export { default as debounce } from "./debounce";
+export { default as decToHexStr } from "./dec-to-hex-str";
+export { default as dictFromTuples } from "./dict-from-tuples";
+export { default as dictItems } from "./dict-items";
+export { default as dictKeys } from "./dict-keys";
+export { default as dictValues } from "./dict-values";
+export { default as download } from "./download";
+export { default as fillInMinWidths } from "./fill-in-min-widths";
+export { default as flatten } from "./flatten";
+export { default as forEach } from "./for-each";
+export { default as forwardEvent } from "./forward-event";
+export { default as genomeLociToPixels } from "./genome-loci-to-pixels";
+export { default as genomicRangeToChromosomeChunks } from "./genomic-range-to-chromosome-chunks";
+export { default as getDefaultTrackForDatatype } from "./get-default-track-for-datatype";
+export { default as getElementDim } from "./get-element-dim";
+export { default as getTrackByUid } from "./get-track-by-uid";
+export { default as getTrackConfFromHGC } from "./get-track-conf-from-hgc";
+export { default as getTrackObjById } from "./get-track-obj-by-id";
+export { default as getTrackPositionByUid } from "./get-track-position-by-uid";
+export { default as getXylofon } from "./get-xylofon";
+export { default as gradient } from "./gradient";
+export { default as hasClass } from "./has-class";
+export { default as hasParent } from "./has-parent";
+export { default as hexStrToInt } from "./hex-string-to-int";
+export { default as intoTheVoid } from "./into-the-void";
+export { default as isTrackOrChildTrack } from "./is-track-or-child-track";
+export { default as isWithin } from "./is-within";
+export { default as latToY } from "./lat-to-y";
+export { default as loadChromInfos } from "./load-chrom-infos";
+export { default as lngToX } from "./lng-to-x";
+export { default as map } from "./map";
+export { default as max } from "./max";
+export { default as maxNonZero } from "./max-non-zero";
+export { default as min } from "./min";
+export { default as minNonZero } from "./min-non-zero";
+export { default as mod } from "./mod";
+export { default as ndarrayAssign } from "./ndarray-assign";
+export { default as ndarrayFlatten } from "./ndarray-flatten";
+export { default as ndarrayToList } from "./ndarray-to-list";
+export { default as numericifyVersion } from "./numericify-version";
+export { default as objVals } from "./obj-vals";
+export { default as or } from "./or";
+export { default as parseChromsizesRows } from "./parse-chromsizes-rows";
+export { default as pixiTextToSvg } from "./pixi-text-to-svg";
+export { default as q } from "./q";
+export { default as reduce } from "./reduce";
+export { default as rangeQuery2d } from "./range-query-2d";
+export { default as relToAbsChromPos } from "./rel-to-abs-chrom-pos";
+export { default as removeClass } from "./remove-class";
+export { default as resetD3BrushStyle } from "./reset-d3-brush-style";
+export { default as rgbToHex } from "./rgb-to-hex";
+export { default as scalesCenterAndK } from "./scales-center-and-k";
+export { default as scalesToGenomeLoci } from "./scales-to-genome-loci";
+export { default as showMousePosition } from "./show-mouse-position";
+export { default as some } from "./some";
+export { default as sum } from "./sum";
+export { default as svgLine } from "./svg-line";
+export { default as throttleAndDebounce } from "./throttle-and-debounce";
+export { default as tileToCanvas } from "./tile-to-canvas";
+export { default as timeout } from "./timeout";
+export { default as totalTrackPixelHeight } from "./total-track-pixel-height";
+export { default as toVoid } from "./to-void";
+export { default as trimTrailingSlash } from "./trim-trailing-slash";
+export { default as valueToColor } from "./value-to-color";
+export { default as expandCombinedTracks } from "./expand-combined-tracks";
+export { default as segmentsToRows } from "./segments-to-rows";
+export { default as visitPositionedTracks } from "./visit-positioned-tracks";
+export { default as visitTracks } from "./visit-tracks";
+export { default as DenseDataExtrema1D } from "./DenseDataExtrema1D";
+export { default as DenseDataExtrema2D } from "./DenseDataExtrema2D";
+export { default as getAggregationFunction } from "./get-aggregation-function";
+export { default as selectedItemsToSize } from "./selected-items-to-size";
+export { default as IS_TRACK_RANGE_SELECTABLE } from "./is-track-range-selectable";
+export { default as getDefaultTracksForDatatype } from "./default-tracks";
+export { default as trackUtils } from "../track-utils";
+export { getTrackObjectFromHGC, getTrackRenderer, getTiledPlot } from "./get-higlass-components";
+export { changeOptions, waitForJsonComplete, waitForTilesLoaded, waitForTransitionsFinished, mountHGComponent, mountHGComponentAsync, removeHGComponent } from "../test-helpers";

package/dist/app/scripts/utils/interval-tree.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Interval tree.
+ *
+ * @public
+ * @constructor
+ */
+export class IntervalTree {
+    /**
+     * Root node of the tree.
+     * @type {IntervalTreeNode | null}
+     */
+    root: IntervalTreeNode | null;
+    /**
+     * Add new interval to the tree.
+     *
+     * @public
+     * @param {Interval} interval - Array with start and end points of the interval.
+     */
+    public add(interval: Interval): void;
+    /**
+     * Checks or point belongs to at least one intarval from the tree.<br><br>
+     * Complexity: O(log N).
+     *
+     * @public
+     * @method
+     * @param {Number} point Point which should be checked.
+     * @return {Boolean} True if point belongs to one of the intervals.
+     */
+    public contains(point: number): boolean;
+    /**
+     * Checks or interval belongs to at least one intarval from the tree.<br><br>
+     * Complexity: O(log N).
+     *
+     * @public
+     * @method
+     * @param {Interval} interval Interval which should be checked.
+     * @return {boolean} True if interval intersects with one of the intervals.
+     */
+    public intersects(interval: Interval): boolean;
+    /**
+     * Returns height of the tree.
+     *
+     * @public
+     * @method
+     * @return {Number} Height of the tree.
+     */
+    public height(): number;
+    /**
+     * Returns node with the max endpoint in subtree.
+     *
+     * @public
+     * @method
+     * @param {IntervalTreeNode} node Root node of subtree.
+     * @return {IntervalTreeNode | null} IntervalTreeNode with the largest endpoint.
+     */
+    public findMax(node: IntervalTreeNode): IntervalTreeNode | null;
+    /**
+     * Adjust the max value.
+     *
+     * @param {Interval} interval
+     * @param {IntervalTreeNode | null} node
+     */
+    _removeHelper(interval: Interval, node: IntervalTreeNode | null): void;
+    /**
+     * Remove interval from the tree.
+     *
+     * @public
+     * @method
+     * @param {Interval} interval - Array with start and end of the interval.
+     */
+    public remove(interval: Interval): void;
+}
+export type Interval = [start: number, end: number];
+/** @typedef {[start: number, end: number]} Interval */
+declare class IntervalTreeNode {
+    /**
+     * @param {number} start
+     * @param {number} end
+     * @param {IntervalTreeNode} [left]
+     * @param {IntervalTreeNode} [right]
+     */
+    constructor(start: number, end: number, left?: IntervalTreeNode, right?: IntervalTreeNode);
+    /**
+     * Node interval.
+     * @type {Interval}
+     */
+    interval: Interval;
+    /**
+     * Max endpoint in subtree which starts from this node.
+     * @type {number}
+     */
+    max: number;
+    /**
+     * Parent node.
+     * @type {IntervalTreeNode | null}
+     */
+    parentNode: IntervalTreeNode | null;
+    /**
+     * Left child node.
+     * @type {IntervalTreeNode | null}
+     */
+    left: IntervalTreeNode | null;
+    /**
+     * Right child node.
+     * @type {IntervalTreeNode | null}
+     */
+    right: IntervalTreeNode | null;
+}
+export {};

package/dist/app/scripts/utils/into-the-void.d.ts

@@ -0,0 +1,6 @@
+export default intoTheVoid;
+/**
+ * An adventure into the abyss of void!
+ * @type {(...args: any[]) => void}  The explorers find nothing but void.
+ */
+declare const intoTheVoid: (...args: any[]) => void;

package/dist/app/scripts/utils/is-track-or-child-track.d.ts

@@ -0,0 +1,7 @@
+export default isTrackOrChildTrack;
+/**
+ * @param {import('../types').TrackObject} testTrack
+ * @param {import('../types').TrackObject} track
+ * @returns {boolean}
+ */
+declare function isTrackOrChildTrack(testTrack: import("../types").TrackObject, track: import("../types").TrackObject): boolean;

package/dist/app/scripts/utils/is-track-range-selectable.d.ts

@@ -0,0 +1,2 @@
+export function IS_TRACK_RANGE_SELECTABLE(track: import("../types").TrackConfig): boolean;
+export default IS_TRACK_RANGE_SELECTABLE;

package/dist/app/scripts/utils/is-within.d.ts

@@ -0,0 +1,12 @@
+export default isWithin;
+/**
+ * Check if a 2D or 1D point is within a rectangle or range
+ * @param {number} x - The point's X coordinate.
+ * @param {number} y - The point's Y coordinate.
+ * @param {number} minX - The rectangle's start X coordinate.
+ * @param {number} maxX - The rectangle's start X coordinate.
+ * @param {number} minY - The rectangle's start X coordinate.
+ * @param {number} maxY - The rectangle's start X coordinate.
+ * @return {boolean} If `true` the [x,y] point is in the rectangle.
+ */
+declare function isWithin(x: number, y: number, minX: number, maxX: number, minY: number, maxY: number, is1d?: boolean): boolean;

package/dist/app/scripts/utils/lat-to-y.d.ts

@@ -0,0 +1,9 @@
+export function invGudermannian(y: number): number;
+export default latToY;
+/**
+ * Translate latitude to Y in the Mercator projection
+ * @param {number} lat - Latitude.
+ * @param {number} zoom - Zoom level
+ * @return {number} Y coordinate in the Mercator projection.
+ */
+declare function latToY(lat: number, zoom: number): number;

package/dist/app/scripts/utils/lng-to-x.d.ts

@@ -0,0 +1,8 @@
+export default lngToX;
+/**
+ * Convert longitude to the X coordinate in the Mercator projection.
+ * @param {number} lng - Longitude
+ * @param {number} zoom - Zoom level
+ * @return {number} X coordinate in the Mercator projection.
+ */
+declare function lngToX(lng: number, zoom: number): number;