monaco-editor11 1.0.9 → 1.1.1

package/dist/workers/editor/common/intervalTree.js

@@ -1,1002 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-function getNodeColor(node) {
-    return ((node.metadata & 1 /* Constants.ColorMask */) >>> 0 /* Constants.ColorOffset */);
-}
-function setNodeColor(node, color) {
-    node.metadata = ((node.metadata & 254 /* Constants.ColorMaskInverse */) | (color << 0 /* Constants.ColorOffset */));
-}
-function getNodeIsVisited(node) {
-    return ((node.metadata & 2 /* Constants.IsVisitedMask */) >>> 1 /* Constants.IsVisitedOffset */) === 1;
-}
-function setNodeIsVisited(node, value) {
-    node.metadata = ((node.metadata & 253 /* Constants.IsVisitedMaskInverse */) | ((value ? 1 : 0) << 1 /* Constants.IsVisitedOffset */));
-}
-function getNodeIsForValidation(node) {
-    return ((node.metadata & 4 /* Constants.IsForValidationMask */) >>> 2 /* Constants.IsForValidationOffset */) === 1;
-}
-function setNodeIsForValidation(node, value) {
-    node.metadata = ((node.metadata & 251 /* Constants.IsForValidationMaskInverse */) | ((value ? 1 : 0) << 2 /* Constants.IsForValidationOffset */));
-}
-function getNodeIsInGlyphMargin(node) {
-    return ((node.metadata & 64 /* Constants.IsMarginMask */) >>> 6 /* Constants.IsMarginOffset */) === 1;
-}
-function setNodeIsInGlyphMargin(node, value) {
-    node.metadata = ((node.metadata & 191 /* Constants.IsMarginMaskInverse */) | ((value ? 1 : 0) << 6 /* Constants.IsMarginOffset */));
-}
-function getNodeAffectsFont(node) {
-    return ((node.metadata & 128 /* Constants.AffectsFontMask */) >>> 7 /* Constants.AffectsFontOffset */) === 1;
-}
-function setNodeAffectsFont(node, value) {
-    node.metadata = ((node.metadata & 127 /* Constants.AffectsFontMaskInverse */) | ((value ? 1 : 0) << 7 /* Constants.AffectsFontOffset */));
-}
-function getNodeStickiness(node) {
-    return ((node.metadata & 24 /* Constants.StickinessMask */) >>> 3 /* Constants.StickinessOffset */);
-}
-function _setNodeStickiness(node, stickiness) {
-    node.metadata = ((node.metadata & 231 /* Constants.StickinessMaskInverse */) | (stickiness << 3 /* Constants.StickinessOffset */));
-}
-function getCollapseOnReplaceEdit(node) {
-    return ((node.metadata & 32 /* Constants.CollapseOnReplaceEditMask */) >>> 5 /* Constants.CollapseOnReplaceEditOffset */) === 1;
-}
-function setCollapseOnReplaceEdit(node, value) {
-    node.metadata = ((node.metadata & 223 /* Constants.CollapseOnReplaceEditMaskInverse */) | ((value ? 1 : 0) << 5 /* Constants.CollapseOnReplaceEditOffset */));
-}
-class IntervalNode {
-    constructor(id, start, end) {
-        this.metadata = 0;
-        this.parent = this;
-        this.left = this;
-        this.right = this;
-        setNodeColor(this, 1 /* NodeColor.Red */);
-        this.start = start;
-        this.end = end;
-        // FORCE_OVERFLOWING_TEST: this.delta = start;
-        this.delta = 0;
-        this.maxEnd = end;
-        this.id = id;
-        this.ownerId = 0;
-        this.options = null;
-        setNodeIsForValidation(this, false);
-        setNodeIsInGlyphMargin(this, false);
-        _setNodeStickiness(this, 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */);
-        setCollapseOnReplaceEdit(this, false);
-        setNodeAffectsFont(this, false);
-        this.cachedVersionId = 0;
-        this.cachedAbsoluteStart = start;
-        this.cachedAbsoluteEnd = end;
-        this.range = null;
-        setNodeIsVisited(this, false);
-    }
-    reset(versionId, start, end, range) {
-        this.start = start;
-        this.end = end;
-        this.maxEnd = end;
-        this.cachedVersionId = versionId;
-        this.cachedAbsoluteStart = start;
-        this.cachedAbsoluteEnd = end;
-        this.range = range;
-    }
-    setOptions(options) {
-        this.options = options;
-        const className = this.options.className;
-        setNodeIsForValidation(this, (className === "squiggly-error" /* ClassName.EditorErrorDecoration */
-            || className === "squiggly-warning" /* ClassName.EditorWarningDecoration */
-            || className === "squiggly-info" /* ClassName.EditorInfoDecoration */));
-        setNodeIsInGlyphMargin(this, this.options.glyphMarginClassName !== null);
-        _setNodeStickiness(this, this.options.stickiness);
-        setCollapseOnReplaceEdit(this, this.options.collapseOnReplaceEdit);
-        setNodeAffectsFont(this, this.options.affectsFont ?? false);
-    }
-    setCachedOffsets(absoluteStart, absoluteEnd, cachedVersionId) {
-        if (this.cachedVersionId !== cachedVersionId) {
-            this.range = null;
-        }
-        this.cachedVersionId = cachedVersionId;
-        this.cachedAbsoluteStart = absoluteStart;
-        this.cachedAbsoluteEnd = absoluteEnd;
-    }
-    detach() {
-        this.parent = null;
-        this.left = null;
-        this.right = null;
-    }
-}
-const SENTINEL = new IntervalNode(null, 0, 0);
-SENTINEL.parent = SENTINEL;
-SENTINEL.left = SENTINEL;
-SENTINEL.right = SENTINEL;
-setNodeColor(SENTINEL, 0 /* NodeColor.Black */);
-class IntervalTree {
-    constructor() {
-        this.root = SENTINEL;
-        this.requestNormalizeDelta = false;
-    }
-    intervalSearch(start, end, filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations) {
-        if (this.root === SENTINEL) {
-            return [];
-        }
-        return intervalSearch(this, start, end, filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations);
-    }
-    search(filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations) {
-        if (this.root === SENTINEL) {
-            return [];
-        }
-        return search(this, filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations);
-    }
-    /**
-     * Will not set `cachedAbsoluteStart` nor `cachedAbsoluteEnd` on the returned nodes!
-     */
-    collectNodesFromOwner(ownerId) {
-        return collectNodesFromOwner(this, ownerId);
-    }
-    /**
-     * Will not set `cachedAbsoluteStart` nor `cachedAbsoluteEnd` on the returned nodes!
-     */
-    collectNodesPostOrder() {
-        return collectNodesPostOrder(this);
-    }
-    insert(node) {
-        rbTreeInsert(this, node);
-        this._normalizeDeltaIfNecessary();
-    }
-    delete(node) {
-        rbTreeDelete(this, node);
-        this._normalizeDeltaIfNecessary();
-    }
-    resolveNode(node, cachedVersionId) {
-        const initialNode = node;
-        let delta = 0;
-        while (node !== this.root) {
-            if (node === node.parent.right) {
-                delta += node.parent.delta;
-            }
-            node = node.parent;
-        }
-        const nodeStart = initialNode.start + delta;
-        const nodeEnd = initialNode.end + delta;
-        initialNode.setCachedOffsets(nodeStart, nodeEnd, cachedVersionId);
-    }
-    acceptReplace(offset, length, textLength, forceMoveMarkers) {
-        // Our strategy is to remove all directly impacted nodes, and then add them back to the tree.
-        // (1) collect all nodes that are intersecting this edit as nodes of interest
-        const nodesOfInterest = searchForEditing(this, offset, offset + length);
-        // (2) remove all nodes that are intersecting this edit
-        for (let i = 0, len = nodesOfInterest.length; i < len; i++) {
-            const node = nodesOfInterest[i];
-            rbTreeDelete(this, node);
-        }
-        this._normalizeDeltaIfNecessary();
-        // (3) edit all tree nodes except the nodes of interest
-        noOverlapReplace(this, offset, offset + length, textLength);
-        this._normalizeDeltaIfNecessary();
-        // (4) edit the nodes of interest and insert them back in the tree
-        for (let i = 0, len = nodesOfInterest.length; i < len; i++) {
-            const node = nodesOfInterest[i];
-            node.start = node.cachedAbsoluteStart;
-            node.end = node.cachedAbsoluteEnd;
-            nodeAcceptEdit(node, offset, (offset + length), textLength, forceMoveMarkers);
-            node.maxEnd = node.end;
-            rbTreeInsert(this, node);
-        }
-        this._normalizeDeltaIfNecessary();
-    }
-    _normalizeDeltaIfNecessary() {
-        if (!this.requestNormalizeDelta) {
-            return;
-        }
-        this.requestNormalizeDelta = false;
-        normalizeDelta(this);
-    }
-}
-//#region Delta Normalization
-function normalizeDelta(T) {
-    let node = T.root;
-    let delta = 0;
-    while (node !== SENTINEL) {
-        if (node.left !== SENTINEL && !getNodeIsVisited(node.left)) {
-            // go left
-            node = node.left;
-            continue;
-        }
-        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {
-            // go right
-            delta += node.delta;
-            node = node.right;
-            continue;
-        }
-        // handle current node
-        node.start = delta + node.start;
-        node.end = delta + node.end;
-        node.delta = 0;
-        recomputeMaxEnd(node);
-        setNodeIsVisited(node, true);
-        // going up from this node
-        setNodeIsVisited(node.left, false);
-        setNodeIsVisited(node.right, false);
-        if (node === node.parent.right) {
-            delta -= node.parent.delta;
-        }
-        node = node.parent;
-    }
-    setNodeIsVisited(T.root, false);
-}
-function adjustMarkerBeforeColumn(markerOffset, markerStickToPreviousCharacter, checkOffset, moveSemantics) {
-    if (markerOffset < checkOffset) {
-        return true;
-    }
-    if (markerOffset > checkOffset) {
-        return false;
-    }
-    if (moveSemantics === 1 /* MarkerMoveSemantics.ForceMove */) {
-        return false;
-    }
-    if (moveSemantics === 2 /* MarkerMoveSemantics.ForceStay */) {
-        return true;
-    }
-    return markerStickToPreviousCharacter;
-}
-/**
- * This is a lot more complicated than strictly necessary to maintain the same behaviour
- * as when decorations were implemented using two markers.
- */
-function nodeAcceptEdit(node, start, end, textLength, forceMoveMarkers) {
-    const nodeStickiness = getNodeStickiness(node);
-    const startStickToPreviousCharacter = (nodeStickiness === 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */
-        || nodeStickiness === 2 /* TrackedRangeStickiness.GrowsOnlyWhenTypingBefore */);
-    const endStickToPreviousCharacter = (nodeStickiness === 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */
-        || nodeStickiness === 2 /* TrackedRangeStickiness.GrowsOnlyWhenTypingBefore */);
-    const deletingCnt = (end - start);
-    const insertingCnt = textLength;
-    const commonLength = Math.min(deletingCnt, insertingCnt);
-    const nodeStart = node.start;
-    let startDone = false;
-    const nodeEnd = node.end;
-    let endDone = false;
-    if (start <= nodeStart && nodeEnd <= end && getCollapseOnReplaceEdit(node)) {
-        // This edit encompasses the entire decoration range
-        // and the decoration has asked to become collapsed
-        node.start = start;
-        startDone = true;
-        node.end = start;
-        endDone = true;
-    }
-    {
-        const moveSemantics = forceMoveMarkers ? 1 /* MarkerMoveSemantics.ForceMove */ : (deletingCnt > 0 ? 2 /* MarkerMoveSemantics.ForceStay */ : 0 /* MarkerMoveSemantics.MarkerDefined */);
-        if (!startDone && adjustMarkerBeforeColumn(nodeStart, startStickToPreviousCharacter, start, moveSemantics)) {
-            startDone = true;
-        }
-        if (!endDone && adjustMarkerBeforeColumn(nodeEnd, endStickToPreviousCharacter, start, moveSemantics)) {
-            endDone = true;
-        }
-    }
-    if (commonLength > 0 && !forceMoveMarkers) {
-        const moveSemantics = (deletingCnt > insertingCnt ? 2 /* MarkerMoveSemantics.ForceStay */ : 0 /* MarkerMoveSemantics.MarkerDefined */);
-        if (!startDone && adjustMarkerBeforeColumn(nodeStart, startStickToPreviousCharacter, start + commonLength, moveSemantics)) {
-            startDone = true;
-        }
-        if (!endDone && adjustMarkerBeforeColumn(nodeEnd, endStickToPreviousCharacter, start + commonLength, moveSemantics)) {
-            endDone = true;
-        }
-    }
-    {
-        const moveSemantics = forceMoveMarkers ? 1 /* MarkerMoveSemantics.ForceMove */ : 0 /* MarkerMoveSemantics.MarkerDefined */;
-        if (!startDone && adjustMarkerBeforeColumn(nodeStart, startStickToPreviousCharacter, end, moveSemantics)) {
-            node.start = start + insertingCnt;
-            startDone = true;
-        }
-        if (!endDone && adjustMarkerBeforeColumn(nodeEnd, endStickToPreviousCharacter, end, moveSemantics)) {
-            node.end = start + insertingCnt;
-            endDone = true;
-        }
-    }
-    // Finish
-    const deltaColumn = (insertingCnt - deletingCnt);
-    if (!startDone) {
-        node.start = Math.max(0, nodeStart + deltaColumn);
-    }
-    if (!endDone) {
-        node.end = Math.max(0, nodeEnd + deltaColumn);
-    }
-    if (node.start > node.end) {
-        node.end = node.start;
-    }
-}
-function searchForEditing(T, start, end) {
-    // https://en.wikipedia.org/wiki/Interval_tree#Augmented_tree
-    // Now, it is known that two intervals A and B overlap only when both
-    // A.low <= B.high and A.high >= B.low. When searching the trees for
-    // nodes overlapping with a given interval, you can immediately skip:
-    //  a) all nodes to the right of nodes whose low value is past the end of the given interval.
-    //  b) all nodes that have their maximum 'high' value below the start of the given interval.
-    let node = T.root;
-    let delta = 0;
-    let nodeMaxEnd = 0;
-    let nodeStart = 0;
-    let nodeEnd = 0;
-    const result = [];
-    let resultLen = 0;
-    while (node !== SENTINEL) {
-        if (getNodeIsVisited(node)) {
-            // going up from this node
-            setNodeIsVisited(node.left, false);
-            setNodeIsVisited(node.right, false);
-            if (node === node.parent.right) {
-                delta -= node.parent.delta;
-            }
-            node = node.parent;
-            continue;
-        }
-        if (!getNodeIsVisited(node.left)) {
-            // first time seeing this node
-            nodeMaxEnd = delta + node.maxEnd;
-            if (nodeMaxEnd < start) {
-                // cover case b) from above
-                // there is no need to search this node or its children
-                setNodeIsVisited(node, true);
-                continue;
-            }
-            if (node.left !== SENTINEL) {
-                // go left
-                node = node.left;
-                continue;
-            }
-        }
-        // handle current node
-        nodeStart = delta + node.start;
-        if (nodeStart > end) {
-            // cover case a) from above
-            // there is no need to search this node or its right subtree
-            setNodeIsVisited(node, true);
-            continue;
-        }
-        nodeEnd = delta + node.end;
-        if (nodeEnd >= start) {
-            node.setCachedOffsets(nodeStart, nodeEnd, 0);
-            result[resultLen++] = node;
-        }
-        setNodeIsVisited(node, true);
-        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {
-            // go right
-            delta += node.delta;
-            node = node.right;
-            continue;
-        }
-    }
-    setNodeIsVisited(T.root, false);
-    return result;
-}
-function noOverlapReplace(T, start, end, textLength) {
-    // https://en.wikipedia.org/wiki/Interval_tree#Augmented_tree
-    // Now, it is known that two intervals A and B overlap only when both
-    // A.low <= B.high and A.high >= B.low. When searching the trees for
-    // nodes overlapping with a given interval, you can immediately skip:
-    //  a) all nodes to the right of nodes whose low value is past the end of the given interval.
-    //  b) all nodes that have their maximum 'high' value below the start of the given interval.
-    let node = T.root;
-    let delta = 0;
-    let nodeMaxEnd = 0;
-    let nodeStart = 0;
-    const editDelta = (textLength - (end - start));
-    while (node !== SENTINEL) {
-        if (getNodeIsVisited(node)) {
-            // going up from this node
-            setNodeIsVisited(node.left, false);
-            setNodeIsVisited(node.right, false);
-            if (node === node.parent.right) {
-                delta -= node.parent.delta;
-            }
-            recomputeMaxEnd(node);
-            node = node.parent;
-            continue;
-        }
-        if (!getNodeIsVisited(node.left)) {
-            // first time seeing this node
-            nodeMaxEnd = delta + node.maxEnd;
-            if (nodeMaxEnd < start) {
-                // cover case b) from above
-                // there is no need to search this node or its children
-                setNodeIsVisited(node, true);
-                continue;
-            }
-            if (node.left !== SENTINEL) {
-                // go left
-                node = node.left;
-                continue;
-            }
-        }
-        // handle current node
-        nodeStart = delta + node.start;
-        if (nodeStart > end) {
-            node.start += editDelta;
-            node.end += editDelta;
-            node.delta += editDelta;
-            if (node.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || node.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {
-                T.requestNormalizeDelta = true;
-            }
-            // cover case a) from above
-            // there is no need to search this node or its right subtree
-            setNodeIsVisited(node, true);
-            continue;
-        }
-        setNodeIsVisited(node, true);
-        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {
-            // go right
-            delta += node.delta;
-            node = node.right;
-            continue;
-        }
-    }
-    setNodeIsVisited(T.root, false);
-}
-//#endregion
-//#region Searching
-function collectNodesFromOwner(T, ownerId) {
-    let node = T.root;
-    const result = [];
-    let resultLen = 0;
-    while (node !== SENTINEL) {
-        if (getNodeIsVisited(node)) {
-            // going up from this node
-            setNodeIsVisited(node.left, false);
-            setNodeIsVisited(node.right, false);
-            node = node.parent;
-            continue;
-        }
-        if (node.left !== SENTINEL && !getNodeIsVisited(node.left)) {
-            // go left
-            node = node.left;
-            continue;
-        }
-        // handle current node
-        if (node.ownerId === ownerId) {
-            result[resultLen++] = node;
-        }
-        setNodeIsVisited(node, true);
-        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {
-            // go right
-            node = node.right;
-            continue;
-        }
-    }
-    setNodeIsVisited(T.root, false);
-    return result;
-}
-function collectNodesPostOrder(T) {
-    let node = T.root;
-    const result = [];
-    let resultLen = 0;
-    while (node !== SENTINEL) {
-        if (getNodeIsVisited(node)) {
-            // going up from this node
-            setNodeIsVisited(node.left, false);
-            setNodeIsVisited(node.right, false);
-            node = node.parent;
-            continue;
-        }
-        if (node.left !== SENTINEL && !getNodeIsVisited(node.left)) {
-            // go left
-            node = node.left;
-            continue;
-        }
-        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {
-            // go right
-            node = node.right;
-            continue;
-        }
-        // handle current node
-        result[resultLen++] = node;
-        setNodeIsVisited(node, true);
-    }
-    setNodeIsVisited(T.root, false);
-    return result;
-}
-function search(T, filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations) {
-    let node = T.root;
-    let delta = 0;
-    let nodeStart = 0;
-    let nodeEnd = 0;
-    const result = [];
-    let resultLen = 0;
-    while (node !== SENTINEL) {
-        if (getNodeIsVisited(node)) {
-            // going up from this node
-            setNodeIsVisited(node.left, false);
-            setNodeIsVisited(node.right, false);
-            if (node === node.parent.right) {
-                delta -= node.parent.delta;
-            }
-            node = node.parent;
-            continue;
-        }
-        if (node.left !== SENTINEL && !getNodeIsVisited(node.left)) {
-            // go left
-            node = node.left;
-            continue;
-        }
-        // handle current node
-        nodeStart = delta + node.start;
-        nodeEnd = delta + node.end;
-        node.setCachedOffsets(nodeStart, nodeEnd, cachedVersionId);
-        let include = true;
-        if (filterOwnerId && node.ownerId && node.ownerId !== filterOwnerId) {
-            include = false;
-        }
-        if (filterOutValidation && getNodeIsForValidation(node)) {
-            include = false;
-        }
-        if (filterFontDecorations && getNodeAffectsFont(node)) {
-            include = false;
-        }
-        if (onlyMarginDecorations && !getNodeIsInGlyphMargin(node)) {
-            include = false;
-        }
-        if (include) {
-            result[resultLen++] = node;
-        }
-        setNodeIsVisited(node, true);
-        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {
-            // go right
-            delta += node.delta;
-            node = node.right;
-            continue;
-        }
-    }
-    setNodeIsVisited(T.root, false);
-    return result;
-}
-function intervalSearch(T, intervalStart, intervalEnd, filterOwnerId, filterOutValidation, filterFontDecorations, cachedVersionId, onlyMarginDecorations) {
-    // https://en.wikipedia.org/wiki/Interval_tree#Augmented_tree
-    // Now, it is known that two intervals A and B overlap only when both
-    // A.low <= B.high and A.high >= B.low. When searching the trees for
-    // nodes overlapping with a given interval, you can immediately skip:
-    //  a) all nodes to the right of nodes whose low value is past the end of the given interval.
-    //  b) all nodes that have their maximum 'high' value below the start of the given interval.
-    let node = T.root;
-    let delta = 0;
-    let nodeMaxEnd = 0;
-    let nodeStart = 0;
-    let nodeEnd = 0;
-    const result = [];
-    let resultLen = 0;
-    while (node !== SENTINEL) {
-        if (getNodeIsVisited(node)) {
-            // going up from this node
-            setNodeIsVisited(node.left, false);
-            setNodeIsVisited(node.right, false);
-            if (node === node.parent.right) {
-                delta -= node.parent.delta;
-            }
-            node = node.parent;
-            continue;
-        }
-        if (!getNodeIsVisited(node.left)) {
-            // first time seeing this node
-            nodeMaxEnd = delta + node.maxEnd;
-            if (nodeMaxEnd < intervalStart) {
-                // cover case b) from above
-                // there is no need to search this node or its children
-                setNodeIsVisited(node, true);
-                continue;
-            }
-            if (node.left !== SENTINEL) {
-                // go left
-                node = node.left;
-                continue;
-            }
-        }
-        // handle current node
-        nodeStart = delta + node.start;
-        if (nodeStart > intervalEnd) {
-            // cover case a) from above
-            // there is no need to search this node or its right subtree
-            setNodeIsVisited(node, true);
-            continue;
-        }
-        nodeEnd = delta + node.end;
-        if (nodeEnd >= intervalStart) {
-            // There is overlap
-            node.setCachedOffsets(nodeStart, nodeEnd, cachedVersionId);
-            let include = true;
-            if (filterOwnerId && node.ownerId && node.ownerId !== filterOwnerId) {
-                include = false;
-            }
-            if (filterOutValidation && getNodeIsForValidation(node)) {
-                include = false;
-            }
-            if (filterFontDecorations && getNodeAffectsFont(node)) {
-                include = false;
-            }
-            if (onlyMarginDecorations && !getNodeIsInGlyphMargin(node)) {
-                include = false;
-            }
-            if (include) {
-                result[resultLen++] = node;
-            }
-        }
-        setNodeIsVisited(node, true);
-        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {
-            // go right
-            delta += node.delta;
-            node = node.right;
-            continue;
-        }
-    }
-    setNodeIsVisited(T.root, false);
-    return result;
-}
-//#endregion
-//#region Insertion
-function rbTreeInsert(T, newNode) {
-    if (T.root === SENTINEL) {
-        newNode.parent = SENTINEL;
-        newNode.left = SENTINEL;
-        newNode.right = SENTINEL;
-        setNodeColor(newNode, 0 /* NodeColor.Black */);
-        T.root = newNode;
-        return T.root;
-    }
-    treeInsert(T, newNode);
-    recomputeMaxEndWalkToRoot(newNode.parent);
-    // repair tree
-    let x = newNode;
-    while (x !== T.root && getNodeColor(x.parent) === 1 /* NodeColor.Red */) {
-        if (x.parent === x.parent.parent.left) {
-            const y = x.parent.parent.right;
-            if (getNodeColor(y) === 1 /* NodeColor.Red */) {
-                setNodeColor(x.parent, 0 /* NodeColor.Black */);
-                setNodeColor(y, 0 /* NodeColor.Black */);
-                setNodeColor(x.parent.parent, 1 /* NodeColor.Red */);
-                x = x.parent.parent;
-            }
-            else {
-                if (x === x.parent.right) {
-                    x = x.parent;
-                    leftRotate(T, x);
-                }
-                setNodeColor(x.parent, 0 /* NodeColor.Black */);
-                setNodeColor(x.parent.parent, 1 /* NodeColor.Red */);
-                rightRotate(T, x.parent.parent);
-            }
-        }
-        else {
-            const y = x.parent.parent.left;
-            if (getNodeColor(y) === 1 /* NodeColor.Red */) {
-                setNodeColor(x.parent, 0 /* NodeColor.Black */);
-                setNodeColor(y, 0 /* NodeColor.Black */);
-                setNodeColor(x.parent.parent, 1 /* NodeColor.Red */);
-                x = x.parent.parent;
-            }
-            else {
-                if (x === x.parent.left) {
-                    x = x.parent;
-                    rightRotate(T, x);
-                }
-                setNodeColor(x.parent, 0 /* NodeColor.Black */);
-                setNodeColor(x.parent.parent, 1 /* NodeColor.Red */);
-                leftRotate(T, x.parent.parent);
-            }
-        }
-    }
-    setNodeColor(T.root, 0 /* NodeColor.Black */);
-    return newNode;
-}
-function treeInsert(T, z) {
-    let delta = 0;
-    let x = T.root;
-    const zAbsoluteStart = z.start;
-    const zAbsoluteEnd = z.end;
-    while (true) {
-        const cmp = intervalCompare(zAbsoluteStart, zAbsoluteEnd, x.start + delta, x.end + delta);
-        if (cmp < 0) {
-            // this node should be inserted to the left
-            // => it is not affected by the node's delta
-            if (x.left === SENTINEL) {
-                z.start -= delta;
-                z.end -= delta;
-                z.maxEnd -= delta;
-                x.left = z;
-                break;
-            }
-            else {
-                x = x.left;
-            }
-        }
-        else {
-            // this node should be inserted to the right
-            // => it is not affected by the node's delta
-            if (x.right === SENTINEL) {
-                z.start -= (delta + x.delta);
-                z.end -= (delta + x.delta);
-                z.maxEnd -= (delta + x.delta);
-                x.right = z;
-                break;
-            }
-            else {
-                delta += x.delta;
-                x = x.right;
-            }
-        }
-    }
-    z.parent = x;
-    z.left = SENTINEL;
-    z.right = SENTINEL;
-    setNodeColor(z, 1 /* NodeColor.Red */);
-}
-//#endregion
-//#region Deletion
-function rbTreeDelete(T, z) {
-    let x;
-    let y;
-    // RB-DELETE except we don't swap z and y in case c)
-    // i.e. we always delete what's pointed at by z.
-    if (z.left === SENTINEL) {
-        x = z.right;
-        y = z;
-        // x's delta is no longer influenced by z's delta
-        x.delta += z.delta;
-        if (x.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || x.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {
-            T.requestNormalizeDelta = true;
-        }
-        x.start += z.delta;
-        x.end += z.delta;
-    }
-    else if (z.right === SENTINEL) {
-        x = z.left;
-        y = z;
-    }
-    else {
-        y = leftest(z.right);
-        x = y.right;
-        // y's delta is no longer influenced by z's delta,
-        // but we don't want to walk the entire right-hand-side subtree of x.
-        // we therefore maintain z's delta in y, and adjust only x
-        x.start += y.delta;
-        x.end += y.delta;
-        x.delta += y.delta;
-        if (x.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || x.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {
-            T.requestNormalizeDelta = true;
-        }
-        y.start += z.delta;
-        y.end += z.delta;
-        y.delta = z.delta;
-        if (y.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || y.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {
-            T.requestNormalizeDelta = true;
-        }
-    }
-    if (y === T.root) {
-        T.root = x;
-        setNodeColor(x, 0 /* NodeColor.Black */);
-        z.detach();
-        resetSentinel();
-        recomputeMaxEnd(x);
-        T.root.parent = SENTINEL;
-        return;
-    }
-    const yWasRed = (getNodeColor(y) === 1 /* NodeColor.Red */);
-    if (y === y.parent.left) {
-        y.parent.left = x;
-    }
-    else {
-        y.parent.right = x;
-    }
-    if (y === z) {
-        x.parent = y.parent;
-    }
-    else {
-        if (y.parent === z) {
-            x.parent = y;
-        }
-        else {
-            x.parent = y.parent;
-        }
-        y.left = z.left;
-        y.right = z.right;
-        y.parent = z.parent;
-        setNodeColor(y, getNodeColor(z));
-        if (z === T.root) {
-            T.root = y;
-        }
-        else {
-            if (z === z.parent.left) {
-                z.parent.left = y;
-            }
-            else {
-                z.parent.right = y;
-            }
-        }
-        if (y.left !== SENTINEL) {
-            y.left.parent = y;
-        }
-        if (y.right !== SENTINEL) {
-            y.right.parent = y;
-        }
-    }
-    z.detach();
-    if (yWasRed) {
-        recomputeMaxEndWalkToRoot(x.parent);
-        if (y !== z) {
-            recomputeMaxEndWalkToRoot(y);
-            recomputeMaxEndWalkToRoot(y.parent);
-        }
-        resetSentinel();
-        return;
-    }
-    recomputeMaxEndWalkToRoot(x);
-    recomputeMaxEndWalkToRoot(x.parent);
-    if (y !== z) {
-        recomputeMaxEndWalkToRoot(y);
-        recomputeMaxEndWalkToRoot(y.parent);
-    }
-    // RB-DELETE-FIXUP
-    let w;
-    while (x !== T.root && getNodeColor(x) === 0 /* NodeColor.Black */) {
-        if (x === x.parent.left) {
-            w = x.parent.right;
-            if (getNodeColor(w) === 1 /* NodeColor.Red */) {
-                setNodeColor(w, 0 /* NodeColor.Black */);
-                setNodeColor(x.parent, 1 /* NodeColor.Red */);
-                leftRotate(T, x.parent);
-                w = x.parent.right;
-            }
-            if (getNodeColor(w.left) === 0 /* NodeColor.Black */ && getNodeColor(w.right) === 0 /* NodeColor.Black */) {
-                setNodeColor(w, 1 /* NodeColor.Red */);
-                x = x.parent;
-            }
-            else {
-                if (getNodeColor(w.right) === 0 /* NodeColor.Black */) {
-                    setNodeColor(w.left, 0 /* NodeColor.Black */);
-                    setNodeColor(w, 1 /* NodeColor.Red */);
-                    rightRotate(T, w);
-                    w = x.parent.right;
-                }
-                setNodeColor(w, getNodeColor(x.parent));
-                setNodeColor(x.parent, 0 /* NodeColor.Black */);
-                setNodeColor(w.right, 0 /* NodeColor.Black */);
-                leftRotate(T, x.parent);
-                x = T.root;
-            }
-        }
-        else {
-            w = x.parent.left;
-            if (getNodeColor(w) === 1 /* NodeColor.Red */) {
-                setNodeColor(w, 0 /* NodeColor.Black */);
-                setNodeColor(x.parent, 1 /* NodeColor.Red */);
-                rightRotate(T, x.parent);
-                w = x.parent.left;
-            }
-            if (getNodeColor(w.left) === 0 /* NodeColor.Black */ && getNodeColor(w.right) === 0 /* NodeColor.Black */) {
-                setNodeColor(w, 1 /* NodeColor.Red */);
-                x = x.parent;
-            }
-            else {
-                if (getNodeColor(w.left) === 0 /* NodeColor.Black */) {
-                    setNodeColor(w.right, 0 /* NodeColor.Black */);
-                    setNodeColor(w, 1 /* NodeColor.Red */);
-                    leftRotate(T, w);
-                    w = x.parent.left;
-                }
-                setNodeColor(w, getNodeColor(x.parent));
-                setNodeColor(x.parent, 0 /* NodeColor.Black */);
-                setNodeColor(w.left, 0 /* NodeColor.Black */);
-                rightRotate(T, x.parent);
-                x = T.root;
-            }
-        }
-    }
-    setNodeColor(x, 0 /* NodeColor.Black */);
-    resetSentinel();
-}
-function leftest(node) {
-    while (node.left !== SENTINEL) {
-        node = node.left;
-    }
-    return node;
-}
-function resetSentinel() {
-    SENTINEL.parent = SENTINEL;
-    SENTINEL.delta = 0; // optional
-    SENTINEL.start = 0; // optional
-    SENTINEL.end = 0; // optional
-}
-//#endregion
-//#region Rotations
-function leftRotate(T, x) {
-    const y = x.right; // set y.
-    y.delta += x.delta; // y's delta is no longer influenced by x's delta
-    if (y.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || y.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {
-        T.requestNormalizeDelta = true;
-    }
-    y.start += x.delta;
-    y.end += x.delta;
-    x.right = y.left; // turn y's left subtree into x's right subtree.
-    if (y.left !== SENTINEL) {
-        y.left.parent = x;
-    }
-    y.parent = x.parent; // link x's parent to y.
-    if (x.parent === SENTINEL) {
-        T.root = y;
-    }
-    else if (x === x.parent.left) {
-        x.parent.left = y;
-    }
-    else {
-        x.parent.right = y;
-    }
-    y.left = x; // put x on y's left.
-    x.parent = y;
-    recomputeMaxEnd(x);
-    recomputeMaxEnd(y);
-}
-function rightRotate(T, y) {
-    const x = y.left;
-    y.delta -= x.delta;
-    if (y.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || y.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {
-        T.requestNormalizeDelta = true;
-    }
-    y.start -= x.delta;
-    y.end -= x.delta;
-    y.left = x.right;
-    if (x.right !== SENTINEL) {
-        x.right.parent = y;
-    }
-    x.parent = y.parent;
-    if (y.parent === SENTINEL) {
-        T.root = x;
-    }
-    else if (y === y.parent.right) {
-        y.parent.right = x;
-    }
-    else {
-        y.parent.left = x;
-    }
-    x.right = y;
-    y.parent = x;
-    recomputeMaxEnd(y);
-    recomputeMaxEnd(x);
-}
-//#endregion
-//#region max end computation
-function computeMaxEnd(node) {
-    let maxEnd = node.end;
-    if (node.left !== SENTINEL) {
-        const leftMaxEnd = node.left.maxEnd;
-        if (leftMaxEnd > maxEnd) {
-            maxEnd = leftMaxEnd;
-        }
-    }
-    if (node.right !== SENTINEL) {
-        const rightMaxEnd = node.right.maxEnd + node.delta;
-        if (rightMaxEnd > maxEnd) {
-            maxEnd = rightMaxEnd;
-        }
-    }
-    return maxEnd;
-}
-function recomputeMaxEnd(node) {
-    node.maxEnd = computeMaxEnd(node);
-}
-function recomputeMaxEndWalkToRoot(node) {
-    while (node !== SENTINEL) {
-        const maxEnd = computeMaxEnd(node);
-        if (node.maxEnd === maxEnd) {
-            // no need to go further
-            return;
-        }
-        node.maxEnd = maxEnd;
-        node = node.parent;
-    }
-}
-//#endregion
-//#region utils
-function intervalCompare(aStart, aEnd, bStart, bEnd) {
-    if (aStart === bStart) {
-        return aEnd - bEnd;
-    }
-    return aStart - bStart;
-}
-//#endregion
-
-export { IntervalNode, IntervalTree, SENTINEL, getNodeColor, intervalCompare, nodeAcceptEdit, recomputeMaxEnd };