@jbrowse/core 3.7.0 → 4.0.0

package/esm/util/calculateDynamicBlocks.js

@@ -0,0 +1,104 @@
+import { getSnapshot, isStateTreeNode } from '@jbrowse/mobx-state-tree';
+import { BlockSet, ContentBlock, ElidedBlock, InterRegionPaddingBlock, } from "./blockTypes.js";
+import { assembleLocStringFast } from "./index.js";
+import { intersection2 } from "./range.js";
+export default function calculateDynamicBlocks(model, padding = true, elision = true) {
+    const { offsetPx, displayedRegions, bpPerPx, width, minimumBlockWidth, interRegionPaddingWidth, } = model;
+    if (!width) {
+        throw new Error('view has no width, cannot calculate displayed blocks');
+    }
+    const invBpPerPx = 1 / bpPerPx;
+    const blocks = new BlockSet();
+    let displayedRegionLeftPx = 0;
+    const windowLeftPx = offsetPx;
+    const windowRightPx = windowLeftPx + width;
+    for (let regionNumber = 0; regionNumber < displayedRegions.length; regionNumber++) {
+        const region = displayedRegions[regionNumber];
+        const { assemblyName, refName, start: regionStart, end: regionEnd, reversed, } = region;
+        const displayedRegionRightPx = displayedRegionLeftPx + (regionEnd - regionStart) * invBpPerPx;
+        const regionWidthPx = (regionEnd - regionStart) * invBpPerPx;
+        const parentRegion = isStateTreeNode(region) ? getSnapshot(region) : region;
+        const [leftPx, rightPx] = intersection2(windowLeftPx, windowRightPx, displayedRegionLeftPx, displayedRegionRightPx);
+        if (leftPx !== undefined && rightPx !== undefined) {
+            let start;
+            let end;
+            let isLeftEndOfDisplayedRegion;
+            let isRightEndOfDisplayedRegion;
+            let blockOffsetPx;
+            if (reversed) {
+                start = Math.max(regionStart, regionEnd - (rightPx - displayedRegionLeftPx) * bpPerPx);
+                end = regionEnd - (leftPx - displayedRegionLeftPx) * bpPerPx;
+                isLeftEndOfDisplayedRegion = end === regionEnd;
+                isRightEndOfDisplayedRegion = start === regionStart;
+                blockOffsetPx = displayedRegionLeftPx + (regionEnd - end) * invBpPerPx;
+            }
+            else {
+                start = (leftPx - displayedRegionLeftPx) * bpPerPx + regionStart;
+                end = Math.min(regionEnd, (rightPx - displayedRegionLeftPx) * bpPerPx + regionStart);
+                isLeftEndOfDisplayedRegion = start === regionStart;
+                isRightEndOfDisplayedRegion = end === regionEnd;
+                blockOffsetPx =
+                    displayedRegionLeftPx + (start - regionStart) * invBpPerPx;
+            }
+            const widthPx = (end - start) * invBpPerPx;
+            const blockData = {
+                assemblyName,
+                refName,
+                start,
+                end,
+                reversed,
+                offsetPx: blockOffsetPx,
+                parentRegion,
+                regionNumber,
+                widthPx,
+                isLeftEndOfDisplayedRegion,
+                isRightEndOfDisplayedRegion,
+                key: `${assembleLocStringFast({
+                    assemblyName,
+                    refName,
+                    start,
+                    end,
+                    reversed,
+                })}-${regionNumber}${reversed ? '-reversed' : ''}`,
+            };
+            if (padding && blocks.length === 0 && isLeftEndOfDisplayedRegion) {
+                blocks.push(new InterRegionPaddingBlock({
+                    key: `${blockData.key}-beforeFirstRegion`,
+                    widthPx: -offsetPx,
+                    offsetPx: blockData.offsetPx + offsetPx,
+                    variant: 'boundary',
+                }));
+            }
+            if (elision && regionWidthPx < minimumBlockWidth) {
+                blocks.push(new ElidedBlock(blockData));
+            }
+            else {
+                blocks.push(new ContentBlock(blockData));
+            }
+            if (padding) {
+                if (regionWidthPx >= minimumBlockWidth &&
+                    blockData.isRightEndOfDisplayedRegion &&
+                    regionNumber < displayedRegions.length - 1) {
+                    blocks.push(new InterRegionPaddingBlock({
+                        key: `${blockData.key}-rightpad`,
+                        widthPx: interRegionPaddingWidth,
+                        offsetPx: blockData.offsetPx + blockData.widthPx,
+                    }));
+                    displayedRegionLeftPx += interRegionPaddingWidth;
+                }
+                if (regionNumber === displayedRegions.length - 1 &&
+                    blockData.isRightEndOfDisplayedRegion) {
+                    blockOffsetPx = blockData.offsetPx + blockData.widthPx;
+                    blocks.push(new InterRegionPaddingBlock({
+                        key: `${blockData.key}-afterLastRegion`,
+                        widthPx: width - blockOffsetPx + offsetPx,
+                        offsetPx: blockOffsetPx,
+                        variant: 'boundary',
+                    }));
+                }
+            }
+        }
+        displayedRegionLeftPx += (regionEnd - regionStart) * invBpPerPx;
+    }
+    return blocks;
+}

package/esm/util/calculateStaticBlocks.d.ts

@@ -0,0 +1,13 @@
+import { BlockSet } from './blockTypes.ts';
+import type { Region } from './types/index.ts';
+import type { Region as RegionModel } from './types/mst.ts';
+import type { Instance } from '@jbrowse/mobx-state-tree';
+export interface Base1DViewModel {
+    offsetPx: number;
+    width: number;
+    displayedRegions: (Region | Instance<typeof RegionModel>)[];
+    bpPerPx: number;
+    minimumBlockWidth: number;
+    interRegionPaddingWidth: number;
+}
+export default function calculateStaticBlocks(model: Base1DViewModel, padding?: boolean, elision?: boolean, extra?: number, width?: number): BlockSet;

package/esm/util/calculateStaticBlocks.js

@@ -0,0 +1,106 @@
+import { getSnapshot, isStateTreeNode } from '@jbrowse/mobx-state-tree';
+import { BlockSet, ContentBlock, ElidedBlock, InterRegionPaddingBlock, } from "./blockTypes.js";
+import { assembleLocStringFast } from "./index.js";
+export default function calculateStaticBlocks(model, padding = true, elision = true, extra = 0, width = 800) {
+    const { offsetPx, displayedRegions, bpPerPx, minimumBlockWidth, interRegionPaddingWidth, width: modelWidth, } = model;
+    const windowLeftBp = offsetPx * bpPerPx;
+    const windowRightBp = (offsetPx + modelWidth) * bpPerPx;
+    const blockSizePx = width;
+    const blockSizeBp = Math.ceil(blockSizePx * bpPerPx);
+    const invBpPerPx = 1 / bpPerPx;
+    const invBlockSizeBp = 1 / blockSizeBp;
+    let regionBpOffset = 0;
+    const blocks = new BlockSet();
+    for (let regionNumber = 0; regionNumber < displayedRegions.length; regionNumber++) {
+        const region = displayedRegions[regionNumber];
+        const { assemblyName, refName, start: regionStart, end: regionEnd, reversed, } = region;
+        const regionBlockCount = Math.ceil((regionEnd - regionStart) * invBlockSizeBp);
+        const parentRegion = isStateTreeNode(region) ? getSnapshot(region) : region;
+        let windowRightBlockNum = Math.floor((windowRightBp - regionBpOffset) * invBlockSizeBp) + extra;
+        if (windowRightBlockNum >= regionBlockCount) {
+            windowRightBlockNum = regionBlockCount - 1;
+        }
+        let windowLeftBlockNum = Math.floor((windowLeftBp - regionBpOffset) * invBlockSizeBp) - extra;
+        if (windowLeftBlockNum < 0) {
+            windowLeftBlockNum = 0;
+        }
+        const regionWidthPx = (regionEnd - regionStart) * invBpPerPx;
+        for (let blockNum = windowLeftBlockNum; blockNum <= windowRightBlockNum; blockNum += 1) {
+            let start;
+            let end;
+            let isLeftEndOfDisplayedRegion;
+            let isRightEndOfDisplayedRegion;
+            if (reversed) {
+                start = Math.max(regionStart, regionEnd - (blockNum + 1) * blockSizeBp);
+                end = regionEnd - blockNum * blockSizeBp;
+                isLeftEndOfDisplayedRegion = end === regionEnd;
+                isRightEndOfDisplayedRegion = start === regionStart;
+            }
+            else {
+                start = regionStart + blockNum * blockSizeBp;
+                end = Math.min(regionEnd, regionStart + (blockNum + 1) * blockSizeBp);
+                isLeftEndOfDisplayedRegion = start === regionStart;
+                isRightEndOfDisplayedRegion = end === regionEnd;
+            }
+            const widthPx = (end - start) * invBpPerPx;
+            const blockData = {
+                assemblyName,
+                refName,
+                start,
+                end,
+                reversed,
+                offsetPx: (regionBpOffset + blockNum * blockSizeBp) * invBpPerPx,
+                parentRegion,
+                regionNumber,
+                widthPx,
+                isLeftEndOfDisplayedRegion,
+                isRightEndOfDisplayedRegion,
+                key: `${assembleLocStringFast({
+                    assemblyName,
+                    refName,
+                    start,
+                    end,
+                    reversed,
+                })}-${regionNumber}${reversed ? '-reversed' : ''}`,
+            };
+            if (padding && regionNumber === 0 && blockNum === 0) {
+                blocks.push(new InterRegionPaddingBlock({
+                    key: `${blockData.key}-beforeFirstRegion`,
+                    widthPx: width,
+                    offsetPx: blockData.offsetPx - width,
+                    variant: 'boundary',
+                }));
+            }
+            if (elision && regionWidthPx < minimumBlockWidth) {
+                blocks.push(new ElidedBlock(blockData));
+            }
+            else {
+                blocks.push(new ContentBlock(blockData));
+            }
+            if (padding) {
+                if (regionWidthPx >= minimumBlockWidth &&
+                    blockData.isRightEndOfDisplayedRegion &&
+                    regionNumber < displayedRegions.length - 1) {
+                    regionBpOffset += interRegionPaddingWidth * bpPerPx;
+                    blocks.push(new InterRegionPaddingBlock({
+                        key: `${blockData.key}-rightpad`,
+                        widthPx: interRegionPaddingWidth,
+                        offsetPx: blockData.offsetPx + blockData.widthPx,
+                    }));
+                }
+                if (regionNumber === displayedRegions.length - 1 &&
+                    blockData.isRightEndOfDisplayedRegion) {
+                    regionBpOffset += interRegionPaddingWidth * bpPerPx;
+                    blocks.push(new InterRegionPaddingBlock({
+                        key: `${blockData.key}-afterLastRegion`,
+                        widthPx: width,
+                        offsetPx: blockData.offsetPx + blockData.widthPx,
+                        variant: 'boundary',
+                    }));
+                }
+            }
+        }
+        regionBpOffset += regionEnd - regionStart;
+    }
+    return blocks;
+}

package/esm/util/coarseStripHTML.d.ts

@@ -0,0 +1 @@
+export declare function coarseStripHTML(s: string): string;

package/esm/util/coarseStripHTML.js

@@ -0,0 +1,17 @@
+export function coarseStripHTML(s) {
+    let result = '';
+    let inTag = false;
+    for (let i = 0, l = s.length; i < l; i++) {
+        const char = s[i];
+        if (char === '<') {
+            inTag = true;
+        }
+        else if (char === '>') {
+            inTag = false;
+        }
+        else if (!inTag) {
+            result += char;
+        }
+    }
+    return result;
+}

package/esm/util/color/cssColorsLevel4.js

@@ -0,0 +1,156 @@
+const colors = {
+    aliceblue: '#F0F8FF',
+    antiquewhite: '#FAEBD7',
+    aqua: '#00FFFF',
+    aquamarine: '#7FFFD4',
+    azure: '#F0FFFF',
+    beige: '#F5F5DC',
+    bisque: '#FFE4C4',
+    black: '#000000',
+    blanchedalmond: '#FFEBCD',
+    blue: '#0000FF',
+    blueviolet: '#8A2BE2',
+    brown: '#A52A2A',
+    burlywood: '#DEB887',
+    cadetblue: '#5F9EA0',
+    chartreuse: '#7FFF00',
+    chocolate: '#D2691E',
+    coral: '#FF7F50',
+    cornflowerblue: '#6495ED',
+    cornsilk: '#FFF8DC',
+    crimson: '#DC143C',
+    cyan: '#00FFFF',
+    darkblue: '#00008B',
+    darkcyan: '#008B8B',
+    darkgoldenrod: '#B8860B',
+    darkgray: '#A9A9A9',
+    darkgreen: '#006400',
+    darkgrey: '#A9A9A9',
+    darkkhaki: '#BDB76B',
+    darkmagenta: '#8B008B',
+    darkolivegreen: '#556B2F',
+    darkorange: '#FF8C00',
+    darkorchid: '#9932CC',
+    darkred: '#8B0000',
+    darksalmon: '#E9967A',
+    darkseagreen: '#8FBC8F',
+    darkslateblue: '#483D8B',
+    darkslategray: '#2F4F4F',
+    darkslategrey: '#2F4F4F',
+    darkturquoise: '#00CED1',
+    darkviolet: '#9400D3',
+    deeppink: '#FF1493',
+    deepskyblue: '#00BFFF',
+    dimgray: '#696969',
+    dimgrey: '#696969',
+    dodgerblue: '#1E90FF',
+    firebrick: '#B22222',
+    floralwhite: '#FFFAF0',
+    forestgreen: '#228B22',
+    fuchsia: '#FF00FF',
+    gainsboro: '#DCDCDC',
+    ghostwhite: '#F8F8FF',
+    gold: '#FFD700',
+    goldenrod: '#DAA520',
+    gray: '#808080',
+    green: '#008000',
+    greenyellow: '#ADFF2F',
+    grey: '#808080',
+    honeydew: '#F0FFF0',
+    hotpink: '#FF69B4',
+    indianred: '#CD5C5C',
+    indigo: '#4B0082',
+    ivory: '#FFFFF0',
+    khaki: '#F0E68C',
+    lavender: '#E6E6FA',
+    lavenderblush: '#FFF0F5',
+    lawngreen: '#7CFC00',
+    lemonchiffon: '#FFFACD',
+    lightblue: '#ADD8E6',
+    lightcoral: '#F08080',
+    lightcyan: '#E0FFFF',
+    lightgoldenrodyellow: '#FAFAD2',
+    lightgray: '#D3D3D3',
+    lightgreen: '#90EE90',
+    lightgrey: '#D3D3D3',
+    lightpink: '#FFB6C1',
+    lightsalmon: '#FFA07A',
+    lightseagreen: '#20B2AA',
+    lightskyblue: '#87CEFA',
+    lightslategray: '#778899',
+    lightslategrey: '#778899',
+    lightsteelblue: '#B0C4DE',
+    lightyellow: '#FFFFE0',
+    lime: '#00FF00',
+    limegreen: '#32CD32',
+    linen: '#FAF0E6',
+    magenta: '#FF00FF',
+    maroon: '#800000',
+    mediumaquamarine: '#66CDAA',
+    mediumblue: '#0000CD',
+    mediumorchid: '#BA55D3',
+    mediumpurple: '#9370DB',
+    mediumseagreen: '#3CB371',
+    mediumslateblue: '#7B68EE',
+    mediumspringgreen: '#00FA9A',
+    mediumturquoise: '#48D1CC',
+    mediumvioletred: '#C71585',
+    midnightblue: '#191970',
+    mintcream: '#F5FFFA',
+    mistyrose: '#FFE4E1',
+    moccasin: '#FFE4B5',
+    navajowhite: '#FFDEAD',
+    navy: '#000080',
+    oldlace: '#FDF5E6',
+    olive: '#808000',
+    olivedrab: '#6B8E23',
+    orange: '#FFA500',
+    orangered: '#FF4500',
+    orchid: '#DA70D6',
+    palegoldenrod: '#EEE8AA',
+    palegreen: '#98FB98',
+    paleturquoise: '#AFEEEE',
+    palevioletred: '#DB7093',
+    papayawhip: '#FFEFD5',
+    peachpuff: '#FFDAB9',
+    peru: '#CD853F',
+    pink: '#FFC0CB',
+    plum: '#DDA0DD',
+    powderblue: '#B0E0E6',
+    purple: '#800080',
+    rebeccapurple: '#663399',
+    red: '#FF0000',
+    rosybrown: '#BC8F8F',
+    royalblue: '#4169E1',
+    saddlebrown: '#8B4513',
+    salmon: '#FA8072',
+    sandybrown: '#F4A460',
+    seagreen: '#2E8B57',
+    seashell: '#FFF5EE',
+    sienna: '#A0522D',
+    silver: '#C0C0C0',
+    skyblue: '#87CEEB',
+    slateblue: '#6A5ACD',
+    slategray: '#708090',
+    slategrey: '#708090',
+    snow: '#FFFAFA',
+    springgreen: '#00FF7F',
+    steelblue: '#4682B4',
+    tan: '#D2B48C',
+    teal: '#008080',
+    thistle: '#D8BFD8',
+    tomato: '#FF6347',
+    turquoise: '#40E0D0',
+    violet: '#EE82EE',
+    wheat: '#F5DEB3',
+    white: '#FFFFFF',
+    whitesmoke: '#F5F5F5',
+    yellow: '#FFFF00',
+    yellowgreen: '#9ACD32',
+};
+export function namedColorToHex(name) {
+    return colors[name];
+}
+export function isNamedColor(name) {
+    return !!colors[name];
+}

package/esm/util/color/index.d.ts

@@ -0,0 +1,5 @@
+export declare function contrastingTextColor(color: string): string;
+export declare function emphasize(color: string, coefficient?: number): string;
+export declare function makeContrasting(foreground: string, background?: string, minContrastRatio?: number): string;
+export { isNamedColor, namedColorToHex } from './cssColorsLevel4.ts';
+export declare function randomColor(str: string): string;

package/esm/util/color/index.js

@@ -0,0 +1,39 @@
+import { darken, emphasize as muiEmphasize, getContrastRatio, getLuminance as muiGetLuminance, lighten, } from '@mui/material/styles';
+import { namedColorToHex } from "./cssColorsLevel4.js";
+export function contrastingTextColor(color) {
+    const luminance = getLuminance(color);
+    return luminance > 0.5 ? 'black' : 'white';
+}
+function getLuminance(color) {
+    const convertedColor = namedColorToHex(color);
+    return muiGetLuminance(convertedColor || color);
+}
+export function emphasize(color, coefficient = 0.15) {
+    const convertedColor = namedColorToHex(color);
+    return muiEmphasize(convertedColor || color, coefficient);
+}
+export function makeContrasting(foreground, background = 'white', minContrastRatio = 3) {
+    let convertedForeground = namedColorToHex(foreground) || foreground;
+    const convertedBackground = namedColorToHex(background) || background;
+    const backgroundLuminance = getLuminance(convertedBackground);
+    let contrastRatio = getContrastRatio(convertedForeground, convertedBackground);
+    const originalColor = convertedForeground;
+    let coefficient = 0.05;
+    while (contrastRatio < minContrastRatio) {
+        convertedForeground =
+            backgroundLuminance > 0.5
+                ? darken(originalColor, coefficient)
+                : lighten(originalColor, coefficient);
+        coefficient += 0.05;
+        contrastRatio = getContrastRatio(convertedForeground, convertedBackground);
+    }
+    return convertedForeground;
+}
+export { isNamedColor, namedColorToHex } from "./cssColorsLevel4.js";
+export function randomColor(str) {
+    let sum = 0;
+    for (let i = 0; i < str.length; i++) {
+        sum += str.charCodeAt(i);
+    }
+    return `hsl(${sum * 10}, 50%, 50%)`;
+}

package/esm/util/colord.d.ts

@@ -0,0 +1,9 @@
+import { colord as colordOriginal } from 'colord';
+import type { AnyColor, Colord as ColordBase } from 'colord';
+export interface Colord extends ColordBase {
+    mix(color2: AnyColor | Colord, ratio?: number): Colord;
+    tints(count?: number): Colord[];
+    shades(count?: number): Colord[];
+    tones(count?: number): Colord[];
+}
+export declare function colord(input: Parameters<typeof colordOriginal>[0]): Colord;

package/esm/util/colord.js

@@ -0,0 +1,14 @@
+import { colord as colordOriginal, extend } from 'colord';
+import mix from 'colord/plugins/mix';
+import names from 'colord/plugins/names';
+let initialized = false;
+function ensurePlugins() {
+    if (!initialized) {
+        extend([mix, names]);
+        initialized = true;
+    }
+}
+export function colord(input) {
+    ensurePlugins();
+    return colordOriginal(input);
+}

package/esm/util/compositeMap.js

@@ -0,0 +1,59 @@
+export default class CompositeMap {
+    submaps;
+    constructor(submaps) {
+        this.submaps = submaps;
+    }
+    has(id) {
+        for (const submap of this.submaps.values()) {
+            if (submap.has(id)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    get(id) {
+        for (const submap of this.submaps.values()) {
+            if (submap.has(id)) {
+                return submap.get(id);
+            }
+        }
+        return undefined;
+    }
+    *values() {
+        for (const key of this.keys()) {
+            yield this.get(key);
+        }
+    }
+    *keys() {
+        const keys = new Set();
+        for (const submap of this.submaps.values()) {
+            for (const key of submap.keys()) {
+                keys.add(key);
+            }
+        }
+        for (const key of keys) {
+            yield key;
+        }
+    }
+    find(f) {
+        for (const submap of this.submaps.values()) {
+            for (const value of submap.values()) {
+                const found = f(value);
+                if (found) {
+                    return value;
+                }
+            }
+        }
+        return undefined;
+    }
+    *[Symbol.iterator]() {
+        for (const key of this.keys()) {
+            yield [key, this.get(key)];
+        }
+    }
+    *entries() {
+        for (const k of this.keys()) {
+            yield [k, this.get(k)];
+        }
+    }
+}

package/esm/util/convertCodingSequenceToPeptides.d.ts

@@ -0,0 +1,6 @@
+import type { Feat } from '../BaseFeatureWidget/util.tsx';
+export declare function convertCodingSequenceToPeptides({ cds, sequence, codonTable, }: {
+    cds: Feat[];
+    sequence: string;
+    codonTable: Record<string, string>;
+}): string;

package/esm/util/convertCodingSequenceToPeptides.js

@@ -0,0 +1,9 @@
+import { stitch } from "../BaseFeatureWidget/util.js";
+export function convertCodingSequenceToPeptides({ cds, sequence, codonTable, }) {
+    const str = stitch(cds, sequence);
+    let protein = '';
+    for (let i = 0; i < str.length; i += 3) {
+        protein += codonTable[str.slice(i, i + 3)] || '&';
+    }
+    return protein;
+}

package/esm/util/dedupe.js

@@ -0,0 +1,12 @@
+export function dedupe(list, hasher = JSON.stringify) {
+    const clone = [];
+    const lookup = new Set();
+    for (const entry of list) {
+        const hashed = hasher(entry);
+        if (!lookup.has(hashed)) {
+            clone.push(entry);
+            lookup.add(hashed);
+        }
+    }
+    return clone;
+}

package/esm/util/fetchSeq.d.ts

@@ -0,0 +1,8 @@
+import type { AbstractSessionModel } from './types/index.ts';
+export declare function fetchSeq({ start, end, refName, assemblyName, session, }: {
+    start: number;
+    end: number;
+    refName: string;
+    assemblyName: string;
+    session: AbstractSessionModel;
+}): Promise<string>;

package/esm/util/fetchSeq.js

@@ -0,0 +1,23 @@
+import { getConf } from "../configuration/index.js";
+export async function fetchSeq({ start, end, refName, assemblyName, session, }) {
+    const { rpcManager, assemblyManager } = session;
+    const assembly = await assemblyManager.waitForAssembly(assemblyName);
+    if (!assembly) {
+        throw new Error('assembly not found');
+    }
+    const sessionId = 'getSequence';
+    const adapterConfig = getConf(assembly, ['sequence', 'adapter']);
+    const canonicalRefName = assembly.getCanonicalRefName2(refName);
+    const seqAdapterRefName = assembly.getSeqAdapterRefName(canonicalRefName);
+    const seq = (await rpcManager.call(sessionId, 'CoreGetSequence', {
+        adapterConfig,
+        sessionId,
+        region: {
+            start,
+            end,
+            refName: seqAdapterRefName,
+            assemblyName,
+        },
+    }));
+    return seq ?? '';
+}

package/esm/util/flatbush/index.d.ts

@@ -0,0 +1,25 @@
+type TypedArrayConstructor = Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor;
+export default class Flatbush {
+    numItems: number;
+    nodeSize: number;
+    byteOffset: number;
+    ArrayType: TypedArrayConstructor;
+    IndexArrayType: Uint16ArrayConstructor | Uint32ArrayConstructor;
+    data: ArrayBufferLike;
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    private _levelBounds;
+    private _boxes;
+    private _indices;
+    private _pos;
+    private _queue;
+    static from(data: ArrayBufferLike, byteOffset?: number): Flatbush;
+    constructor(numItems: number, nodeSize?: number, ArrayType?: TypedArrayConstructor, ArrayBufferType?: ArrayBufferConstructor | SharedArrayBufferConstructor, data?: ArrayBufferLike, byteOffset?: number);
+    add(minX: number, minY: number, maxX?: number, maxY?: number): number;
+    finish(): void;
+    search(minX: number, minY: number, maxX: number, maxY: number, filterFn?: (index: number, x0: number, y0: number, x1: number, y1: number) => boolean): number[];
+    neighbors(x: number, y: number, maxResults?: number, maxDistance?: number, filterFn?: (index: number) => boolean): number[];
+}
+export {};