@jbrowse/core 4.0.4 → 4.1.1

package/esm/ui/FileSelector/LocalFileChooser.js

@@ -1,39 +1,103 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Button, FormControl, Typography } from '@mui/material';
+import { isFileSystemAccessSupported } from "../../util/fileHandleStore.js";
 import { isElectron } from "../../util/index.js";
-import { getBlob, storeBlobLocation } from "../../util/tracks.js";
+import { ensureFileHandleReady, getBlob, getFileFromCache, storeBlobLocation, storeFileHandleLocation, } from "../../util/tracks.js";
 import { makeStyles } from "../../util/tss-react/index.js";
-function isLocalPathLocation(loc) {
-    return 'localPath' in loc;
-}
-function isBlobLocation(loc) {
-    return 'blobId' in loc;
-}
+import { isBlobLocation, isFileHandleLocation, isLocalPathLocation, } from "../../util/types/index.js";
 const useStyles = makeStyles()(theme => ({
     filename: {
         marginLeft: theme.spacing(1),
     },
 }));
+const supportsFileSystemAccess = isFileSystemAccessSupported() && !isElectron;
+function getFilename(location) {
+    if (!location) {
+        return undefined;
+    }
+    if (isBlobLocation(location)) {
+        return location.name;
+    }
+    if (isLocalPathLocation(location)) {
+        return location.localPath;
+    }
+    if (isFileHandleLocation(location)) {
+        return location.name;
+    }
+    return undefined;
+}
+function needsReload(location) {
+    if (!location) {
+        return false;
+    }
+    if (isBlobLocation(location)) {
+        return !getBlob(location.blobId);
+    }
+    if (isFileHandleLocation(location)) {
+        return !getFileFromCache(location.handleId);
+    }
+    return false;
+}
+async function openFileSystemAccessPicker() {
+    const [handle] = await window.showOpenFilePicker();
+    return storeFileHandleLocation(handle);
+}
+function FilePickerButton({ setLocation, }) {
+    if (supportsFileSystemAccess) {
+        return (_jsx(Button, { variant: "outlined", onClick: async () => {
+                try {
+                    setLocation(await openFileSystemAccessPicker());
+                }
+                catch (e) {
+                    if (e.name !== 'AbortError') {
+                        throw e;
+                    }
+                }
+            }, children: "Choose File" }));
+    }
+    return (_jsxs(Button, { variant: "outlined", component: "label", children: ["Choose File", _jsx("input", { type: "file", hidden: true, onChange: ({ target }) => {
+                    const file = target.files?.[0];
+                    if (file) {
+                        if (isElectron) {
+                            const { webUtils } = window.require('electron');
+                            setLocation({
+                                localPath: webUtils.getPathForFile(file),
+                                locationType: 'LocalPathLocation',
+                            });
+                        }
+                        else {
+                            const loc = storeBlobLocation({ blob: file });
+                            if ('blobId' in loc) {
+                                setLocation(loc);
+                            }
+                        }
+                    }
+                } })] }));
+}
+function ReloadPrompt({ location, setLocation, }) {
+    const handleReopen = async () => {
+        if (isFileHandleLocation(location)) {
+            try {
+                await ensureFileHandleReady(location.handleId, true);
+                setLocation({ ...location });
+            }
+            catch {
+                try {
+                    setLocation(await openFileSystemAccessPicker());
+                }
+                catch (e) {
+                    if (e.name !== 'AbortError') {
+                        throw e;
+                    }
+                }
+            }
+        }
+    };
+    return (_jsxs(Box, { display: "flex", alignItems: "center", gap: 1, children: [_jsx(Typography, { color: "error", children: "(need to reload)" }), isFileHandleLocation(location) && (_jsx(Button, { size: "small", variant: "text", color: "primary", onClick: handleReopen, children: "Reopen" }))] }));
+}
 function LocalFileChooser({ location, setLocation, }) {
     const { classes } = useStyles();
-    const filename = location &&
-        ((isBlobLocation(location) && location.name) ||
-            (isLocalPathLocation(location) && location.localPath));
-    const needToReload = location && isBlobLocation(location) && !getBlob(location.blobId);
-    return (_jsxs(Box, { display: "flex", flexDirection: "row", alignItems: "center", children: [_jsx(Box, { children: _jsx(FormControl, { fullWidth: true, children: _jsxs(Button, { variant: "outlined", component: "label", children: ["Choose File", _jsx("input", { type: "file", hidden: true, onChange: ({ target }) => {
-                                    const file = target.files?.[0];
-                                    if (file) {
-                                        if (isElectron) {
-                                            const { webUtils } = window.require('electron');
-                                            setLocation({
-                                                localPath: webUtils.getPathForFile(file),
-                                                locationType: 'LocalPathLocation',
-                                            });
-                                        }
-                                        else {
-                                            setLocation(storeBlobLocation({ blob: file }));
-                                        }
-                                    }
-                                } })] }) }) }), _jsxs(Box, { children: [_jsx(Typography, { component: "span", className: classes.filename, color: filename ? 'initial' : 'textSecondary', children: filename || 'No file chosen' }), needToReload ? (_jsx(Typography, { color: "error", children: "(need to reload)" })) : null] })] }));
+    const filename = getFilename(location);
+    return (_jsxs(Box, { display: "flex", flexDirection: "row", alignItems: "center", children: [_jsx(Box, { children: _jsx(FormControl, { fullWidth: true, children: _jsx(FilePickerButton, { setLocation: setLocation }) }) }), _jsxs(Box, { children: [_jsx(Typography, { component: "span", className: classes.filename, color: filename ? 'initial' : 'textSecondary', children: filename || 'No file chosen' }), location && needsReload(location) && (_jsx(ReloadPrompt, { location: location, setLocation: setLocation }))] })] }));
 }
 export default LocalFileChooser;

package/esm/ui/FileSelector/SourceTypeSelector.js

@@ -1,38 +1,23 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useState } from 'react';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import ArrowDropDownIcon from '@mui/icons-material/ArrowDropDown';
-import { Menu, MenuItem, ToggleButton, ToggleButtonGroup, Tooltip, } from '@mui/material';
-function shorten(str, len) {
-    return str.length > len ? `${str.slice(0, len)}…` : str;
+import { ToggleButton, ToggleButtonGroup, Tooltip } from '@mui/material';
+import CascadingMenuButton from "../CascadingMenuButton.js";
+import { getAccountLabel, isAdminMode } from "./util.js";
+function AccountToggleButton({ account, }) {
+    return (_jsx(Tooltip, { title: account.name, children: _jsx(ToggleButton, { value: account.internetAccountId, children: getAccountLabel(account) }) }));
 }
-function ToggleButtonWithTooltip(props) {
-    const { title, children, ...other } = props;
-    return (_jsx(Tooltip, { title: title || '', children: _jsx(ToggleButton, { ...other, children: children }) }));
-}
-const isAdminMode = () => new URLSearchParams(window.location.search).get('adminKey') !== null;
-function HiddenAccountsMenu({ anchorEl, hiddenAccountIds, accountMap, onClose, onSelect, }) {
-    if (!anchorEl) {
-        return null;
-    }
-    return (_jsx(Menu, { open: true, anchorEl: anchorEl, anchorOrigin: { vertical: 'bottom', horizontal: 'center' }, transformOrigin: { vertical: 'top', horizontal: 'center' }, onClose: onClose, children: hiddenAccountIds.map(id => (_jsx(MenuItem, { value: id, onClick: () => {
-                onSelect(id);
-            }, children: accountMap[id].name }, id))) }));
+function MoreButton({ onClick, disabled, children, }) {
+    return (_jsx(ToggleButton, { value: "more", selected: false, disabled: disabled, onClick: e => {
+            onClick(e);
+        }, children: children }));
 }
 export default function SourceTypeSelector({ value, shownAccountIds, hiddenAccountIds, accountMap, onChange, onHiddenAccountSelect, }) {
-    const [anchorEl, setAnchorEl] = useState(null);
-    return (_jsxs(_Fragment, { children: [_jsxs(ToggleButtonGroup, { value: value, exclusive: true, size: "small", onChange: onChange, "aria-label": "file, url, or account picker", children: [isAdminMode() ? null : (_jsx(ToggleButton, { size: "small", value: "file", "aria-label": "local file", children: "File" })), _jsx(ToggleButton, { size: "small", value: "url", "aria-label": "url", children: "URL" }), shownAccountIds.map(id => {
-                        const account = accountMap[id];
-                        const { toggleContents, name: accountName } = account;
-                        const label = typeof toggleContents === 'string'
-                            ? shorten(toggleContents, 5)
-                            : toggleContents || shorten(accountName, 5);
-                        return (_jsx(ToggleButtonWithTooltip, { value: id, title: accountName, children: label }, id));
-                    }), hiddenAccountIds.length > 0 ? (_jsxs(ToggleButton, { value: "more", onClick: event => {
-                            setAnchorEl(event.target);
-                        }, selected: false, children: ["More", _jsx(ArrowDropDownIcon, {})] })) : null] }), _jsx(HiddenAccountsMenu, { anchorEl: anchorEl, hiddenAccountIds: hiddenAccountIds, accountMap: accountMap, onClose: () => {
-                    setAnchorEl(null);
-                }, onSelect: id => {
-                    onHiddenAccountSelect(id);
-                    setAnchorEl(null);
-                } })] }));
+    const shownAccounts = shownAccountIds.map(id => accountMap[id]);
+    const hiddenAccounts = hiddenAccountIds.map(id => accountMap[id]);
+    return (_jsxs(ToggleButtonGroup, { value: value, exclusive: true, size: "small", onChange: onChange, "aria-label": "file, url, or account picker", children: [!isAdminMode() && (_jsx(ToggleButton, { value: "file", "aria-label": "local file", children: "File" })), _jsx(ToggleButton, { value: "url", "aria-label": "url", children: "URL" }), shownAccounts.map(account => (_jsx(AccountToggleButton, { account: account }, account.internetAccountId))), hiddenAccounts.length > 0 && (_jsxs(CascadingMenuButton, { menuItems: hiddenAccounts.map(account => ({
+                    label: account.name,
+                    onClick: () => {
+                        onHiddenAccountSelect(account.internetAccountId);
+                    },
+                })), ButtonComponent: MoreButton, anchorOrigin: { vertical: 'bottom', horizontal: 'center' }, transformOrigin: { vertical: 'top', horizontal: 'center' }, children: ["More", _jsx(ArrowDropDownIcon, {})] }))] }));
 }

package/esm/ui/FileSelector/util.d.ts

@@ -0,0 +1,8 @@
+import type { BaseInternetAccountModel } from '../../pluggableElementTypes/index.ts';
+import type { FileLocation } from '../../util/index.ts';
+export declare const MAX_LABEL_LENGTH = 5;
+export declare function isAdminMode(): boolean;
+export declare function shorten(str: string): string;
+export declare function getAccountLabel(account: BaseInternetAccountModel): string | number | bigint | true | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined>;
+export declare function getInitialSourceType(location?: FileLocation): string;
+export declare function addAccountToLocation(location: FileLocation, account?: BaseInternetAccountModel): FileLocation;

package/esm/ui/FileSelector/util.js

@@ -0,0 +1,34 @@
+import { isUriLocation } from "../../util/index.js";
+export const MAX_LABEL_LENGTH = 5;
+export function isAdminMode() {
+    return (typeof window !== 'undefined' &&
+        new URLSearchParams(window.location.search).get('adminKey') !== null);
+}
+export function shorten(str) {
+    return str.length > MAX_LABEL_LENGTH
+        ? `${str.slice(0, MAX_LABEL_LENGTH)}…`
+        : str;
+}
+export function getAccountLabel(account) {
+    const { toggleContents, name } = account;
+    if (toggleContents) {
+        return typeof toggleContents === 'string'
+            ? shorten(toggleContents)
+            : toggleContents;
+    }
+    return shorten(name);
+}
+export function getInitialSourceType(location) {
+    if (location &&
+        'internetAccountId' in location &&
+        location.internetAccountId) {
+        return location.internetAccountId;
+    }
+    return !location || isUriLocation(location) ? 'url' : 'file';
+}
+export function addAccountToLocation(location, account) {
+    if (account && isUriLocation(location)) {
+        return { ...location, internetAccountId: account.internetAccountId };
+    }
+    return location;
+}

package/esm/ui/SnackbarContents.js

@@ -3,9 +3,9 @@ import CloseIcon from '@mui/icons-material/Close';
 import Report from '@mui/icons-material/Report';
 import { Alert, Button, IconButton, Snackbar as MUISnackbar, } from '@mui/material';
 export default function SnackbarContents({ onClose, contents, }) {
-    const actionName = contents.action?.name;
-    return (_jsx(MUISnackbar, { open: true, onClose: onClose, anchorOrigin: { vertical: 'bottom', horizontal: 'center' }, children: _jsx(Alert, { onClose: onClose, action: contents.action ? (_jsxs(_Fragment, { children: [_jsx(Button, { color: "inherit", onClick: e => {
-                            contents.action?.onClick();
+    const { actions } = contents;
+    return (_jsx(MUISnackbar, { open: true, onClose: onClose, anchorOrigin: { vertical: 'bottom', horizontal: 'center' }, children: _jsx(Alert, { onClose: onClose, action: actions?.length ? (_jsxs(_Fragment, { children: [actions.map((action, idx) => (_jsx(Button, { color: "inherit", onClick: e => {
+                            action.onClick();
                             onClose(e);
-                        }, children: actionName === 'report' ? _jsx(Report, {}) : actionName }), _jsx(IconButton, { color: "inherit", onClick: onClose, children: _jsx(CloseIcon, {}) })] })) : null, severity: contents.level || 'warning', children: contents.message }) }));
+                        }, children: action.name === 'report' ? _jsx(Report, {}) : action.name }, idx))), _jsx(IconButton, { color: "inherit", onClick: onClose, children: _jsx(CloseIcon, {}) })] })) : null, severity: contents.level || 'warning', children: contents.message }) }));
 }

package/esm/ui/SnackbarModel.d.ts

@@ -2,16 +2,16 @@ import type { NotificationLevel, SnackAction } from '../util/types/index.ts';
 export interface SnackbarMessage {
     message: string;
     level?: NotificationLevel;
-    action?: SnackAction;
+    actions?: SnackAction[];
 }
 export default function SnackbarModel(): import("@jbrowse/mobx-state-tree").IModelType<{}, {
     snackbarMessages: import("mobx").IObservableArray<SnackbarMessage>;
 } & {
     readonly snackbarMessageSet: Map<string, SnackbarMessage>;
 } & {
-    notify(message: string, level?: NotificationLevel, action?: SnackAction): void;
-    notifyError(errorMessage: string, error?: unknown, extra?: unknown): void;
-    pushSnackbarMessage(message: string, level?: NotificationLevel, action?: SnackAction): void;
+    notify(message: string, level?: NotificationLevel, action?: SnackAction | SnackAction[]): void;
+    notifyError(errorMessage: string, error?: unknown, extra?: unknown, action?: SnackAction): void;
+    pushSnackbarMessage(message: string, level?: NotificationLevel, actions?: SnackAction[]): void;
     popSnackbarMessage(): SnackbarMessage | undefined;
     removeSnackbarMessage(message: string): void;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/ui/SnackbarModel.js

@@ -15,15 +15,20 @@ export default function SnackbarModel() {
     }))
         .actions(self => ({
         notify(message, level, action) {
-            this.pushSnackbarMessage(message, level, action);
+            const actions = action
+                ? Array.isArray(action)
+                    ? action
+                    : [action]
+                : undefined;
+            this.pushSnackbarMessage(message, level, actions);
             if (level === 'info' || level === 'success') {
                 setTimeout(() => {
                     this.removeSnackbarMessage(message);
                 }, 5000);
             }
         },
-        notifyError(errorMessage, error, extra) {
-            this.notify(errorMessage, 'error', {
+        notifyError(errorMessage, error, extra, action) {
+            const reportAction = {
                 name: 'report',
                 onClick: () => {
                     self.queueDialog((onClose) => [
@@ -35,11 +40,17 @@ export default function SnackbarModel() {
                         },
                     ]);
                 },
-            });
+            };
+            const actions = action ? [reportAction, action] : [reportAction];
+            this.pushSnackbarMessage(errorMessage, 'error', actions);
         },
-        pushSnackbarMessage(message, level, action) {
-            if (action || !self.snackbarMessageSet.has(message)) {
-                self.snackbarMessages.push({ message, level, action });
+        pushSnackbarMessage(message, level, actions) {
+            if (actions?.length || !self.snackbarMessageSet.has(message)) {
+                self.snackbarMessages.push({
+                    message,
+                    level,
+                    actions,
+                });
             }
         },
         popSnackbarMessage() {

package/esm/ui/index.d.ts

@@ -7,7 +7,7 @@ export { default as Dialog } from './Dialog.tsx';
 export { default as EditableTypography } from './EditableTypography.tsx';
 export { default as ErrorMessage } from './ErrorMessage.tsx';
 export { default as FatalErrorDialog } from './FatalErrorDialog.tsx';
-export { default as FileSelector } from './FileSelector/index.ts';
+export { default as FileSelector } from './FileSelector/FileSelector.tsx';
 export { default as LoadingEllipses } from './LoadingEllipses.tsx';
 export { default as Menu } from './Menu.tsx';
 export { default as PrerenderedCanvas } from './PrerenderedCanvas.tsx';

package/esm/ui/index.js

@@ -7,7 +7,7 @@ export { default as Dialog } from "./Dialog.js";
 export { default as EditableTypography } from "./EditableTypography.js";
 export { default as ErrorMessage } from "./ErrorMessage.js";
 export { default as FatalErrorDialog } from "./FatalErrorDialog.js";
-export { default as FileSelector } from "./FileSelector/index.js";
+export { default as FileSelector } from "./FileSelector/FileSelector.js";
 export { default as LoadingEllipses } from "./LoadingEllipses.js";
 export { default as Menu } from "./Menu.js";
 export { default as PrerenderedCanvas } from "./PrerenderedCanvas.js";

package/esm/util/IntervalTree.d.ts

@@ -0,0 +1,42 @@
+declare const RB_TREE_COLOR_RED = 1;
+declare const RB_TREE_COLOR_BLACK = 0;
+type NodeColor = typeof RB_TREE_COLOR_RED | typeof RB_TREE_COLOR_BLACK;
+declare class Interval {
+    low: number;
+    high: number;
+    constructor(low: number, high: number);
+    lessThan(other: Interval): boolean;
+    equalTo(other: Interval): boolean;
+    intersects(other: Interval): boolean;
+    merge(other: Interval): Interval;
+}
+declare class Node<V> {
+    left: Node<V> | null;
+    right: Node<V> | null;
+    parent: Node<V> | null;
+    color: NodeColor;
+    key: Interval | undefined;
+    values: V[];
+    max: Interval | undefined;
+    constructor(key?: Interval | [number, number], value?: V, left?: Node<V> | null, right?: Node<V> | null, parent?: Node<V> | null, color?: NodeColor);
+    lessThan(other: Node<V>): boolean;
+    equalTo(other: Node<V>): boolean;
+    intersects(other: Node<V>): boolean;
+    updateMax(): void;
+    notIntersectLeftSubtree(searchNode: Node<V>): boolean;
+    notIntersectRightSubtree(searchNode: Node<V>): boolean;
+}
+export declare class IntervalTree<V> {
+    root: Node<V> | null;
+    private nilNode;
+    insert(key: [number, number], value: V): Node<V>;
+    search(interval: [number, number]): V[];
+    private recalcMax;
+    private treeInsert;
+    private insertFixup;
+    private treeSearch;
+    private treeSearchInterval;
+    private rotateLeft;
+    private rotateRight;
+}
+export {};

package/esm/util/IntervalTree.js

@@ -0,0 +1,257 @@
+const RB_TREE_COLOR_RED = 1;
+const RB_TREE_COLOR_BLACK = 0;
+class Interval {
+    low;
+    high;
+    constructor(low, high) {
+        this.low = low;
+        this.high = high;
+    }
+    lessThan(other) {
+        return (this.low < other.low || (this.low === other.low && this.high < other.high));
+    }
+    equalTo(other) {
+        return this.low === other.low && this.high === other.high;
+    }
+    intersects(other) {
+        return !(this.high < other.low || other.high < this.low);
+    }
+    merge(other) {
+        return new Interval(Math.min(this.low, other.low), Math.max(this.high, other.high));
+    }
+}
+class Node {
+    left = null;
+    right = null;
+    parent = null;
+    color = RB_TREE_COLOR_BLACK;
+    key;
+    values = [];
+    max;
+    constructor(key, value, left, right, parent, color) {
+        if (left !== undefined) {
+            this.left = left;
+        }
+        if (right !== undefined) {
+            this.right = right;
+        }
+        if (parent !== undefined) {
+            this.parent = parent;
+        }
+        if (color !== undefined) {
+            this.color = color;
+        }
+        if (value !== undefined) {
+            this.values.push(value);
+        }
+        if (key !== undefined) {
+            if (Array.isArray(key)) {
+                const [low, high] = key;
+                this.key =
+                    low <= high ? new Interval(low, high) : new Interval(high, low);
+            }
+            else {
+                this.key = key;
+            }
+            this.max = this.key;
+        }
+    }
+    lessThan(other) {
+        return this.key.lessThan(other.key);
+    }
+    equalTo(other) {
+        return this.key.equalTo(other.key);
+    }
+    intersects(other) {
+        return this.key.intersects(other.key);
+    }
+    updateMax() {
+        this.max = this.key;
+        if (this.right?.max && this.max) {
+            this.max = this.max.merge(this.right.max);
+        }
+        if (this.left?.max && this.max) {
+            this.max = this.max.merge(this.left.max);
+        }
+    }
+    notIntersectLeftSubtree(searchNode) {
+        if (!this.left) {
+            return true;
+        }
+        const high = this.left.max?.high ?? this.left.key.high;
+        return high < searchNode.key.low;
+    }
+    notIntersectRightSubtree(searchNode) {
+        if (!this.right) {
+            return true;
+        }
+        const low = this.right.max?.low ?? this.right.key.low;
+        return searchNode.key.high < low;
+    }
+}
+export class IntervalTree {
+    root = null;
+    nilNode = new Node();
+    insert(key, value) {
+        const existing = this.treeSearch(this.root, new Node(key));
+        if (existing) {
+            existing.values.push(value);
+            return existing;
+        }
+        const insertNode = new Node(key, value, this.nilNode, this.nilNode, null, RB_TREE_COLOR_RED);
+        this.treeInsert(insertNode);
+        this.recalcMax(insertNode);
+        return insertNode;
+    }
+    search(interval) {
+        const searchNode = new Node(interval);
+        const resultNodes = [];
+        this.treeSearchInterval(this.root, searchNode, resultNodes);
+        const results = [];
+        for (const node of resultNodes) {
+            for (const v of node.values) {
+                results.push(v);
+            }
+        }
+        return results;
+    }
+    recalcMax(node) {
+        let current = node;
+        while (current.parent != null) {
+            current.parent.updateMax();
+            current = current.parent;
+        }
+    }
+    treeInsert(insertNode) {
+        let current = this.root;
+        let parent = null;
+        if (this.root == null || this.root === this.nilNode) {
+            this.root = insertNode;
+        }
+        else {
+            while (current !== this.nilNode) {
+                parent = current;
+                current = insertNode.lessThan(current) ? current.left : current.right;
+            }
+            insertNode.parent = parent;
+            if (insertNode.lessThan(parent)) {
+                parent.left = insertNode;
+            }
+            else {
+                parent.right = insertNode;
+            }
+        }
+        this.insertFixup(insertNode);
+    }
+    insertFixup(insertNode) {
+        let current = insertNode;
+        while (current !== this.root &&
+            current.parent.color === RB_TREE_COLOR_RED) {
+            if (current.parent === current.parent.parent.left) {
+                const uncle = current.parent.parent.right;
+                if (uncle.color === RB_TREE_COLOR_RED) {
+                    current.parent.color = RB_TREE_COLOR_BLACK;
+                    uncle.color = RB_TREE_COLOR_BLACK;
+                    current.parent.parent.color = RB_TREE_COLOR_RED;
+                    current = current.parent.parent;
+                }
+                else {
+                    if (current === current.parent.right) {
+                        current = current.parent;
+                        this.rotateLeft(current);
+                    }
+                    current.parent.color = RB_TREE_COLOR_BLACK;
+                    current.parent.parent.color = RB_TREE_COLOR_RED;
+                    this.rotateRight(current.parent.parent);
+                }
+            }
+            else {
+                const uncle = current.parent.parent.left;
+                if (uncle.color === RB_TREE_COLOR_RED) {
+                    current.parent.color = RB_TREE_COLOR_BLACK;
+                    uncle.color = RB_TREE_COLOR_BLACK;
+                    current.parent.parent.color = RB_TREE_COLOR_RED;
+                    current = current.parent.parent;
+                }
+                else {
+                    if (current === current.parent.left) {
+                        current = current.parent;
+                        this.rotateRight(current);
+                    }
+                    current.parent.color = RB_TREE_COLOR_BLACK;
+                    current.parent.parent.color = RB_TREE_COLOR_RED;
+                    this.rotateLeft(current.parent.parent);
+                }
+            }
+        }
+        this.root.color = RB_TREE_COLOR_BLACK;
+    }
+    treeSearch(node, searchNode) {
+        if (node == null || node === this.nilNode) {
+            return undefined;
+        }
+        if (searchNode.equalTo(node)) {
+            return node;
+        }
+        return searchNode.lessThan(node)
+            ? this.treeSearch(node.left, searchNode)
+            : this.treeSearch(node.right, searchNode);
+    }
+    treeSearchInterval(node, searchNode, results) {
+        if (node != null && node !== this.nilNode) {
+            if (node.left !== this.nilNode &&
+                !node.notIntersectLeftSubtree(searchNode)) {
+                this.treeSearchInterval(node.left, searchNode, results);
+            }
+            if (node.intersects(searchNode)) {
+                results.push(node);
+            }
+            if (node.right !== this.nilNode &&
+                !node.notIntersectRightSubtree(searchNode)) {
+                this.treeSearchInterval(node.right, searchNode, results);
+            }
+        }
+    }
+    rotateLeft(x) {
+        const y = x.right;
+        x.right = y.left;
+        if (y.left !== this.nilNode) {
+            y.left.parent = x;
+        }
+        y.parent = x.parent;
+        if (x === this.root) {
+            this.root = y;
+        }
+        else if (x === x.parent.left) {
+            x.parent.left = y;
+        }
+        else {
+            x.parent.right = y;
+        }
+        y.left = x;
+        x.parent = y;
+        x.updateMax();
+        y.updateMax();
+    }
+    rotateRight(y) {
+        const x = y.left;
+        y.left = x.right;
+        if (x.right !== this.nilNode) {
+            x.right.parent = y;
+        }
+        x.parent = y.parent;
+        if (y === this.root) {
+            this.root = x;
+        }
+        else if (y === y.parent.left) {
+            y.parent.left = x;
+        }
+        else {
+            y.parent.right = x;
+        }
+        x.right = y;
+        y.parent = x;
+        y.updateMax();
+        x.updateMax();
+    }
+}