@microsoft/powerquery-language-services 0.10.6 → 0.11.3

package/lib/powerquery-language-services/inspection/activeNode/activeNodeUtils.js

@@ -1,352 +1,352 @@
-"use strict";
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findNodeKind = exports.isPositionInBounds = exports.assertPositionInBounds = exports.assertGetLeaf = exports.assertActiveNode = exports.createOutOfBoundPosition = exports.activeNode = void 0;
-const parser_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/parser");
-const powerquery_parser_1 = require("@microsoft/powerquery-parser");
-const language_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/language");
-const activeNode_1 = require("./activeNode");
-const __1 = require("../..");
-function activeNode(nodeIdMapCollection, position) {
-    const astSearched = leafSearch(nodeIdMapCollection, position);
-    const { nodeClosestBeforePosition, nodeOnPosition, nodeClosestAfterPosition } = leafSearch(nodeIdMapCollection, position);
-    const contextClosestOnOrAfterPosition = findContext(nodeIdMapCollection, astSearched);
-    let leaf;
-    let leafKind;
-    // Case 1: empty document
-    if (nodeClosestBeforePosition === undefined &&
-        nodeOnPosition === undefined &&
-        nodeClosestAfterPosition === undefined) {
-        return createOutOfBoundPosition(position);
-    }
-    // Case 2: There's only 1 leaf
-    // Case 2a: truthy left
-    // `not |`
-    // `foo |`
-    else if (nodeClosestBeforePosition !== undefined &&
-        nodeOnPosition === undefined &&
-        nodeClosestAfterPosition === undefined) {
-        // With context
-        // `not |`
-        if (contextClosestOnOrAfterPosition !== undefined) {
-            leaf = parser_1.XorNodeUtils.boxContext(contextClosestOnOrAfterPosition);
-            leafKind = activeNode_1.ActiveNodeLeafKind.ContextNode;
-        }
-        // Without context
-        // `foo |`
-        else {
-            leaf = parser_1.XorNodeUtils.boxAst(nodeClosestBeforePosition);
-            leafKind = activeNode_1.ActiveNodeLeafKind.IsBeforePosition;
-        }
-    }
-    // Case 2b: truthy center
-    // `|not`
-    // `not|`
-    // `|foo`
-    // `foo|`
-    else if (nodeClosestBeforePosition === undefined &&
-        nodeOnPosition !== undefined &&
-        nodeClosestAfterPosition === undefined) {
-        // With or without context
-        leaf = parser_1.XorNodeUtils.boxAst(nodeOnPosition);
-        leafKind = activeNode_1.ActiveNodeLeafKind.IsInAst;
-    }
-    // Case 2c: truthy right
-    // `| not`
-    // `| 1`
-    else if (nodeClosestBeforePosition === undefined &&
-        nodeOnPosition === undefined &&
-        nodeClosestAfterPosition !== undefined) {
-        // With or without context
-        return createOutOfBoundPosition(position);
-    }
-    // Case 3: There's 2 leafs.
-    // Case 3a: truthy left and center
-    // `1+|1`
-    // `if |true`
-    // `if true|`
-    // `{1, foo|`
-    else if (nodeClosestBeforePosition !== undefined &&
-        nodeOnPosition !== undefined &&
-        nodeClosestAfterPosition == undefined) {
-        // With or without context
-        leaf = parser_1.XorNodeUtils.boxAst(nodeOnPosition);
-        leafKind = activeNode_1.ActiveNodeLeafKind.IsInAst;
-    }
-    // Case 3b: truthy left and right
-    else if (nodeClosestBeforePosition !== undefined &&
-        nodeOnPosition === undefined &&
-        nodeClosestAfterPosition !== undefined) {
-        if (language_1.AstUtils.isNodeKind(nodeClosestBeforePosition, language_1.Ast.NodeKind.Constant) &&
-            ShiftRightConstantKinds.includes(nodeClosestBeforePosition.constantKind)) {
-            leaf = parser_1.XorNodeUtils.boxAst(nodeClosestAfterPosition);
-            leafKind = activeNode_1.ActiveNodeLeafKind.IsAfterPosition;
-        }
-        else {
-            leaf = parser_1.XorNodeUtils.boxAst(nodeClosestBeforePosition);
-            leafKind = activeNode_1.ActiveNodeLeafKind.IsBeforePosition;
-        }
-    }
-    // Case 3c: truthy center and right
-    // `|not true
-    else if (nodeClosestBeforePosition === undefined &&
-        nodeOnPosition !== undefined &&
-        nodeClosestAfterPosition !== undefined) {
-        leaf = parser_1.XorNodeUtils.boxAst(nodeOnPosition);
-        leafKind = activeNode_1.ActiveNodeLeafKind.IsInAst;
-    }
-    // Case 4: There's 3 leafs
-    else if (nodeClosestBeforePosition !== undefined &&
-        nodeOnPosition !== undefined &&
-        nodeClosestAfterPosition !== undefined) {
-        leaf = parser_1.XorNodeUtils.boxAst(nodeOnPosition);
-        leafKind = activeNode_1.ActiveNodeLeafKind.IsInAst;
-    }
-    // Case 5: TypeScript can't tell this is exhaustive.
-    else {
-        throw new powerquery_parser_1.CommonError.InvariantError(`this should never be reached`);
-    }
-    const inclusiveIdentifierUnderPosition = findLeafIdentifier(nodeIdMapCollection, leaf);
-    const exclusiveIdentifierUnderPosition = inclusiveIdentifierUnderPosition &&
-        __1.PositionUtils.isInAst(position, inclusiveIdentifierUnderPosition.node, false, true)
-        ? inclusiveIdentifierUnderPosition
-        : undefined;
-    const ancestry = parser_1.AncestryUtils.assertAncestry(nodeIdMapCollection, leaf.node.id);
-    return {
-        kind: activeNode_1.ActiveNodeKind.ActiveNode,
-        leafKind,
-        position,
-        ancestry,
-        isInKey: isInKey(ancestry),
-        exclusiveIdentifierUnderPosition,
-        inclusiveIdentifierUnderPosition,
-    };
-}
-exports.activeNode = activeNode;
-function createOutOfBoundPosition(position) {
-    return {
-        kind: activeNode_1.ActiveNodeKind.OutOfBoundPosition,
-        position,
-    };
-}
-exports.createOutOfBoundPosition = createOutOfBoundPosition;
-function assertActiveNode(nodeIdMapCollection, position) {
-    const value = activeNode(nodeIdMapCollection, position);
-    assertPositionInBounds(value);
-    return value;
-}
-exports.assertActiveNode = assertActiveNode;
-function assertGetLeaf(activeNode) {
-    return parser_1.AncestryUtils.assertNth(activeNode.ancestry, 0);
-}
-exports.assertGetLeaf = assertGetLeaf;
-function assertPositionInBounds(value) {
-    if (!isPositionInBounds(value)) {
-        throw new powerquery_parser_1.CommonError.InvariantError(`value was not in bounds`);
-    }
-}
-exports.assertPositionInBounds = assertPositionInBounds;
-function isPositionInBounds(value) {
-    return value.kind === activeNode_1.ActiveNodeKind.ActiveNode;
-}
-exports.isPositionInBounds = isPositionInBounds;
-function findNodeKind(activeNode, nodeKind) {
-    return parser_1.AncestryUtils.findNodeKind(activeNode.ancestry, nodeKind);
-}
-exports.findNodeKind = findNodeKind;
-const ShiftLeftConstantKinds = [
-    language_1.Constant.WrapperConstant.RightBrace,
-    language_1.Constant.WrapperConstant.RightBracket,
-    language_1.Constant.WrapperConstant.RightParenthesis,
-];
-const ShiftRightConstantKinds = [
-    ...language_1.Constant.BinOpExpressionOperators,
-    language_1.Constant.MiscConstant.Ampersand,
-    language_1.Constant.MiscConstant.Comma,
-    language_1.Constant.MiscConstant.DotDot,
-    language_1.Constant.MiscConstant.Equal,
-    language_1.Constant.MiscConstant.FatArrow,
-    language_1.Constant.MiscConstant.NullCoalescingOperator,
-    language_1.Constant.MiscConstant.QuestionMark,
-    language_1.Constant.MiscConstant.Semicolon,
-    language_1.Constant.WrapperConstant.LeftBrace,
-    language_1.Constant.WrapperConstant.LeftBracket,
-    language_1.Constant.WrapperConstant.LeftParenthesis,
-];
-// Searches for the closest leaf to the left, right, and on the given position if such an option exists.
-function leafSearch(nodeIdMapCollection, position) {
-    const astNodeById = nodeIdMapCollection.astNodeById;
-    let nodeClosestBeforePosition;
-    let nodeOnPosition;
-    let nodeClosestAfterPosition;
-    // Find the closest leaf on or to the left of the position.
-    for (const nodeId of nodeIdMapCollection.leafIds) {
-        const candidate = astNodeById.get(nodeId);
-        powerquery_parser_1.Assert.isDefined(candidate, `leafIds contained a value that wasn't found in astNodeById`, { nodeId });
-        language_1.AstUtils.assertIsLeaf(candidate);
-        // This shouldn't occur, but safety first.
-        if (candidate === undefined) {
-            continue;
-        }
-        let includeLowerBound = true;
-        let includeUpperBound = true;
-        if (language_1.AstUtils.isNodeKind(candidate, language_1.Ast.NodeKind.Constant)) {
-            if (ShiftRightConstantKinds.includes(candidate.constantKind)) {
-                includeLowerBound = false;
-                includeUpperBound = false;
-            }
-            else if (ShiftLeftConstantKinds.includes(candidate.constantKind)) {
-                includeLowerBound = false;
-            }
-        }
-        // If the candidate starts under the cursor position then it's safe to assume it's the best candidate,
-        // as each leaf node is guaranteed to be non-overlapping.
-        if (__1.PositionUtils.isInAst(position, candidate, includeLowerBound, includeUpperBound)) {
-            nodeOnPosition = candidate;
-        }
-        // Else if the candidate is before the cursor position
-        else if (__1.PositionUtils.isAfterAst(position, candidate, includeUpperBound)) {
-            // And we either haven't found a closestNodeOnOrBeforePosition yet,
-            // or if the candidate is better (more right) than the current closestNodeOnOrBeforePosition.
-            if (nodeClosestBeforePosition === undefined ||
-                nodeClosestBeforePosition.tokenRange.tokenIndexStart < candidate.tokenRange.tokenIndexStart) {
-                nodeClosestBeforePosition = candidate;
-            }
-        }
-        // Else the candidate must be after the cursor position.
-        // And we either haven't found a closestAfterPosition yet,
-        // or if the candidate is better (more left) than the current nodeClosestAfterPosition.
-        else if (nodeClosestAfterPosition === undefined ||
-            nodeClosestAfterPosition.tokenRange.tokenIndexStart > candidate.tokenRange.tokenIndexStart) {
-            nodeClosestAfterPosition = candidate;
-        }
-    }
-    return {
-        nodeClosestBeforePosition,
-        nodeOnPosition,
-        nodeClosestAfterPosition,
-    };
-}
-function findContext(nodeIdMapCollection, searchedLeafs) {
-    var _a, _b, _c, _d, _e;
-    const tokenIndexLowBound = (_d = (_b = (_a = searchedLeafs.nodeClosestAfterPosition) === null || _a === void 0 ? void 0 : _a.tokenRange.tokenIndexStart) !== null && _b !== void 0 ? _b : (_c = searchedLeafs.nodeOnPosition) === null || _c === void 0 ? void 0 : _c.tokenRange.tokenIndexStart) !== null && _d !== void 0 ? _d : (_e = searchedLeafs.nodeClosestBeforePosition) === null || _e === void 0 ? void 0 : _e.tokenRange.tokenIndexStart;
-    if (tokenIndexLowBound === undefined) {
-        return undefined;
-    }
-    // Look for the deepest ParseContext that starts on or before the cursor.
-    // We can use searchedLeafs to generate a bound on tokenIndex.
-    // It's possible/likely that multiple ParseContexts exist with the same tokenIndex,
-    // so we pick the "deepest" one.
-    const depthCache = new Map();
-    let closestContextOnOrAfterPosition = undefined;
-    for (const candidate of nodeIdMapCollection.contextNodeById.values()) {
-        if (candidate.tokenIndexStart < tokenIndexLowBound) {
-            continue;
-        }
-        if (closestContextOnOrAfterPosition === undefined ||
-            candidate.tokenIndexStart > closestContextOnOrAfterPosition.tokenIndexStart ||
-            findDepth(nodeIdMapCollection.parentIdById, candidate.id, depthCache) >
-                findDepth(nodeIdMapCollection.parentIdById, closestContextOnOrAfterPosition.id, depthCache)) {
-            closestContextOnOrAfterPosition = candidate;
-        }
-    }
-    return closestContextOnOrAfterPosition;
-}
-function findDepth(parentIdById, nodeId, depthCache) {
-    const cachedDepth = depthCache.get(nodeId);
-    if (cachedDepth !== undefined) {
-        return cachedDepth;
-    }
-    const parentId = parentIdById.get(nodeId);
-    if (parentId === undefined) {
-        return 0;
-    }
-    const summedDepth = 1 + findDepth(parentIdById, parentId, depthCache);
-    depthCache.set(nodeId, summedDepth);
-    return summedDepth;
-}
-function findLeafIdentifier(nodeIdMapCollection, leafXorNode) {
-    if (parser_1.XorNodeUtils.isContext(leafXorNode)) {
-        return undefined;
-    }
-    const leaf = leafXorNode.node;
-    let identifier;
-    const parentId = nodeIdMapCollection.parentIdById.get(leaf.id);
-    if (leaf.kind === language_1.Ast.NodeKind.Identifier) {
-        if (parentId === undefined) {
-            identifier = leaf;
-        }
-        else {
-            const parent = parser_1.NodeIdMapUtils.ast(nodeIdMapCollection, parentId);
-            if ((parent === null || parent === void 0 ? void 0 : parent.kind) === language_1.Ast.NodeKind.IdentifierPairedExpression) {
-                identifier = leaf;
-            }
-            else if ((parent === null || parent === void 0 ? void 0 : parent.kind) === language_1.Ast.NodeKind.IdentifierExpression) {
-                identifier = parent;
-            }
-            else {
-                identifier = leaf;
-            }
-        }
-    }
-    // If '@', then check if it's part of an IdentifierExpression.
-    else if (leaf.kind === language_1.Ast.NodeKind.Constant && leaf.constantKind === language_1.Constant.MiscConstant.AtSign) {
-        if (parentId === undefined) {
-            return undefined;
-        }
-        const parent = parser_1.NodeIdMapUtils.ast(nodeIdMapCollection, parentId);
-        if ((parent === null || parent === void 0 ? void 0 : parent.kind) === language_1.Ast.NodeKind.IdentifierExpression) {
-            identifier = parent;
-        }
-        else {
-            return undefined;
-        }
-    }
-    else if (leaf.kind === language_1.Ast.NodeKind.GeneralizedIdentifier) {
-        identifier = leaf;
-    }
-    else {
-        return undefined;
-    }
-    let result;
-    switch (identifier.kind) {
-        case language_1.Ast.NodeKind.Identifier:
-        case language_1.Ast.NodeKind.GeneralizedIdentifier:
-            result = {
-                node: identifier,
-                isRecursive: false,
-                normalizedLiteral: language_1.IdentifierUtils.assertNormalizedIdentifier(identifier.literal, {
-                    allowGeneralizedIdentifier: identifier.kind === language_1.Ast.NodeKind.GeneralizedIdentifier,
-                }),
-                normalizedRecursiveLiteral: undefined,
-            };
-            break;
-        case language_1.Ast.NodeKind.IdentifierExpression: {
-            const normalizedLiteral = language_1.IdentifierUtils.assertNormalizedIdentifier(identifier.identifier.literal, { allowGeneralizedIdentifier: false });
-            result = {
-                node: identifier,
-                normalizedLiteral,
-                normalizedRecursiveLiteral: identifier.inclusiveConstant ? `@${normalizedLiteral}` : undefined,
-            };
-            break;
-        }
-        default:
-            throw powerquery_parser_1.Assert.isNever(identifier);
-    }
-    return result;
-}
-function isInKey(ancestry) {
-    if (ancestry.length < 2) {
-        return false;
-    }
-    const child = powerquery_parser_1.ArrayUtils.assertGet(ancestry, 0);
-    const parent = powerquery_parser_1.ArrayUtils.assertGet(ancestry, 1);
-    // Return true if we're in the key portion of a key-value pair.
-    return ([
-        language_1.Ast.NodeKind.GeneralizedIdentifierPairedAnyLiteral,
-        language_1.Ast.NodeKind.GeneralizedIdentifierPairedExpression,
-        language_1.Ast.NodeKind.IdentifierPairedExpression,
-    ].includes(parent.node.kind) && child.node.attributeIndex === 0);
-}
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activeNode = activeNode;
+exports.createOutOfBoundPosition = createOutOfBoundPosition;
+exports.assertActiveNode = assertActiveNode;
+exports.assertGetLeaf = assertGetLeaf;
+exports.assertPositionInBounds = assertPositionInBounds;
+exports.isPositionInBounds = isPositionInBounds;
+exports.findNodeKind = findNodeKind;
+const parser_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/parser");
+const powerquery_parser_1 = require("@microsoft/powerquery-parser");
+const language_1 = require("@microsoft/powerquery-parser/lib/powerquery-parser/language");
+const activeNode_1 = require("./activeNode");
+const __1 = require("../..");
+function activeNode(nodeIdMapCollection, position) {
+    const astSearched = leafSearch(nodeIdMapCollection, position);
+    const { nodeClosestBeforePosition, nodeOnPosition, nodeClosestAfterPosition } = leafSearch(nodeIdMapCollection, position);
+    const contextClosestOnOrAfterPosition = findContext(nodeIdMapCollection, astSearched);
+    let leaf;
+    let leafKind;
+    // Case 1: empty document
+    if (nodeClosestBeforePosition === undefined &&
+        nodeOnPosition === undefined &&
+        nodeClosestAfterPosition === undefined) {
+        return createOutOfBoundPosition(position);
+    }
+    // Case 2: There's only 1 leaf
+    // Case 2a: truthy left
+    // `not |`
+    // `foo |`
+    else if (nodeClosestBeforePosition !== undefined &&
+        nodeOnPosition === undefined &&
+        nodeClosestAfterPosition === undefined) {
+        // With context
+        // `not |`
+        if (contextClosestOnOrAfterPosition !== undefined) {
+            leaf = parser_1.XorNodeUtils.boxContext(contextClosestOnOrAfterPosition);
+            leafKind = activeNode_1.ActiveNodeLeafKind.ContextNode;
+        }
+        // Without context
+        // `foo |`
+        else {
+            leaf = parser_1.XorNodeUtils.boxAst(nodeClosestBeforePosition);
+            leafKind = activeNode_1.ActiveNodeLeafKind.IsBeforePosition;
+        }
+    }
+    // Case 2b: truthy center
+    // `|not`
+    // `not|`
+    // `|foo`
+    // `foo|`
+    else if (nodeClosestBeforePosition === undefined &&
+        nodeOnPosition !== undefined &&
+        nodeClosestAfterPosition === undefined) {
+        // With or without context
+        leaf = parser_1.XorNodeUtils.boxAst(nodeOnPosition);
+        leafKind = activeNode_1.ActiveNodeLeafKind.IsInAst;
+    }
+    // Case 2c: truthy right
+    // `| not`
+    // `| 1`
+    else if (nodeClosestBeforePosition === undefined &&
+        nodeOnPosition === undefined &&
+        nodeClosestAfterPosition !== undefined) {
+        // With or without context
+        return createOutOfBoundPosition(position);
+    }
+    // Case 3: There's 2 leafs.
+    // Case 3a: truthy left and center
+    // `1+|1`
+    // `if |true`
+    // `if true|`
+    // `{1, foo|`
+    else if (nodeClosestBeforePosition !== undefined &&
+        nodeOnPosition !== undefined &&
+        nodeClosestAfterPosition == undefined) {
+        // With or without context
+        leaf = parser_1.XorNodeUtils.boxAst(nodeOnPosition);
+        leafKind = activeNode_1.ActiveNodeLeafKind.IsInAst;
+    }
+    // Case 3b: truthy left and right
+    else if (nodeClosestBeforePosition !== undefined &&
+        nodeOnPosition === undefined &&
+        nodeClosestAfterPosition !== undefined) {
+        if (language_1.AstUtils.isNodeKind(nodeClosestBeforePosition, language_1.Ast.NodeKind.Constant) &&
+            ShiftRightConstantKinds.includes(nodeClosestBeforePosition.constantKind)) {
+            leaf = parser_1.XorNodeUtils.boxAst(nodeClosestAfterPosition);
+            leafKind = activeNode_1.ActiveNodeLeafKind.IsAfterPosition;
+        }
+        else {
+            leaf = parser_1.XorNodeUtils.boxAst(nodeClosestBeforePosition);
+            leafKind = activeNode_1.ActiveNodeLeafKind.IsBeforePosition;
+        }
+    }
+    // Case 3c: truthy center and right
+    // `|not true
+    else if (nodeClosestBeforePosition === undefined &&
+        nodeOnPosition !== undefined &&
+        nodeClosestAfterPosition !== undefined) {
+        leaf = parser_1.XorNodeUtils.boxAst(nodeOnPosition);
+        leafKind = activeNode_1.ActiveNodeLeafKind.IsInAst;
+    }
+    // Case 4: There's 3 leafs
+    else if (nodeClosestBeforePosition !== undefined &&
+        nodeOnPosition !== undefined &&
+        nodeClosestAfterPosition !== undefined) {
+        leaf = parser_1.XorNodeUtils.boxAst(nodeOnPosition);
+        leafKind = activeNode_1.ActiveNodeLeafKind.IsInAst;
+    }
+    // Case 5: TypeScript can't tell this is exhaustive.
+    else {
+        throw new powerquery_parser_1.CommonError.InvariantError(`this should never be reached`);
+    }
+    const inclusiveIdentifierUnderPosition = findLeafIdentifier(nodeIdMapCollection, leaf);
+    const exclusiveIdentifierUnderPosition = inclusiveIdentifierUnderPosition &&
+        __1.PositionUtils.isInAst(position, inclusiveIdentifierUnderPosition.node, false, true)
+        ? inclusiveIdentifierUnderPosition
+        : undefined;
+    const ancestry = parser_1.AncestryUtils.assertAncestry(nodeIdMapCollection, leaf.node.id);
+    return {
+        kind: activeNode_1.ActiveNodeKind.ActiveNode,
+        leafKind,
+        position,
+        ancestry,
+        isInKey: isInKey(ancestry),
+        exclusiveIdentifierUnderPosition,
+        inclusiveIdentifierUnderPosition,
+    };
+}
+function createOutOfBoundPosition(position) {
+    return {
+        kind: activeNode_1.ActiveNodeKind.OutOfBoundPosition,
+        position,
+    };
+}
+function assertActiveNode(nodeIdMapCollection, position) {
+    const value = activeNode(nodeIdMapCollection, position);
+    assertPositionInBounds(value);
+    return value;
+}
+function assertGetLeaf(activeNode) {
+    return parser_1.AncestryUtils.assertNth(activeNode.ancestry, 0);
+}
+function assertPositionInBounds(value) {
+    if (!isPositionInBounds(value)) {
+        throw new powerquery_parser_1.CommonError.InvariantError(`value was not in bounds`);
+    }
+}
+function isPositionInBounds(value) {
+    return value.kind === activeNode_1.ActiveNodeKind.ActiveNode;
+}
+function findNodeKind(activeNode, nodeKind) {
+    return parser_1.AncestryUtils.findNodeKind(activeNode.ancestry, nodeKind);
+}
+const ShiftLeftConstantKinds = [
+    language_1.Constant.WrapperConstant.RightBrace,
+    language_1.Constant.WrapperConstant.RightBracket,
+    language_1.Constant.WrapperConstant.RightParenthesis,
+];
+const ShiftRightConstantKinds = [
+    ...language_1.Constant.BinOpExpressionOperators,
+    language_1.Constant.MiscConstant.Ampersand,
+    language_1.Constant.MiscConstant.Comma,
+    language_1.Constant.MiscConstant.DotDot,
+    language_1.Constant.MiscConstant.Equal,
+    language_1.Constant.MiscConstant.FatArrow,
+    language_1.Constant.MiscConstant.NullCoalescingOperator,
+    language_1.Constant.MiscConstant.QuestionMark,
+    language_1.Constant.MiscConstant.Semicolon,
+    language_1.Constant.WrapperConstant.LeftBrace,
+    language_1.Constant.WrapperConstant.LeftBracket,
+    language_1.Constant.WrapperConstant.LeftParenthesis,
+];
+// Searches for the closest leaf to the left, right, and on the given position if such an option exists.
+function leafSearch(nodeIdMapCollection, position) {
+    const astNodeById = nodeIdMapCollection.astNodeById;
+    let nodeClosestBeforePosition;
+    let nodeOnPosition;
+    let nodeClosestAfterPosition;
+    // Find the closest leaf on or to the left of the position.
+    for (const nodeId of nodeIdMapCollection.leafIds) {
+        const candidate = astNodeById.get(nodeId);
+        powerquery_parser_1.Assert.isDefined(candidate, `leafIds contained a value that wasn't found in astNodeById`, { nodeId });
+        language_1.AstUtils.assertIsLeaf(candidate);
+        // This shouldn't occur, but safety first.
+        if (candidate === undefined) {
+            continue;
+        }
+        let includeLowerBound = true;
+        let includeUpperBound = true;
+        if (language_1.AstUtils.isNodeKind(candidate, language_1.Ast.NodeKind.Constant)) {
+            if (ShiftRightConstantKinds.includes(candidate.constantKind)) {
+                includeLowerBound = false;
+                includeUpperBound = false;
+            }
+            else if (ShiftLeftConstantKinds.includes(candidate.constantKind)) {
+                includeLowerBound = false;
+            }
+        }
+        // If the candidate starts under the cursor position then it's safe to assume it's the best candidate,
+        // as each leaf node is guaranteed to be non-overlapping.
+        if (__1.PositionUtils.isInAst(position, candidate, includeLowerBound, includeUpperBound)) {
+            nodeOnPosition = candidate;
+        }
+        // Else if the candidate is before the cursor position
+        else if (__1.PositionUtils.isAfterAst(position, candidate, includeUpperBound)) {
+            // And we either haven't found a closestNodeOnOrBeforePosition yet,
+            // or if the candidate is better (more right) than the current closestNodeOnOrBeforePosition.
+            if (nodeClosestBeforePosition === undefined ||
+                nodeClosestBeforePosition.tokenRange.tokenIndexStart < candidate.tokenRange.tokenIndexStart) {
+                nodeClosestBeforePosition = candidate;
+            }
+        }
+        // Else the candidate must be after the cursor position.
+        // And we either haven't found a closestAfterPosition yet,
+        // or if the candidate is better (more left) than the current nodeClosestAfterPosition.
+        else if (nodeClosestAfterPosition === undefined ||
+            nodeClosestAfterPosition.tokenRange.tokenIndexStart > candidate.tokenRange.tokenIndexStart) {
+            nodeClosestAfterPosition = candidate;
+        }
+    }
+    return {
+        nodeClosestBeforePosition,
+        nodeOnPosition,
+        nodeClosestAfterPosition,
+    };
+}
+function findContext(nodeIdMapCollection, searchedLeafs) {
+    const tokenIndexLowBound = searchedLeafs.nodeClosestAfterPosition?.tokenRange.tokenIndexStart ??
+        searchedLeafs.nodeOnPosition?.tokenRange.tokenIndexStart ??
+        searchedLeafs.nodeClosestBeforePosition?.tokenRange.tokenIndexStart;
+    if (tokenIndexLowBound === undefined) {
+        return undefined;
+    }
+    // Look for the deepest ParseContext that starts on or before the cursor.
+    // We can use searchedLeafs to generate a bound on tokenIndex.
+    // It's possible/likely that multiple ParseContexts exist with the same tokenIndex,
+    // so we pick the "deepest" one.
+    const depthCache = new Map();
+    let closestContextOnOrAfterPosition = undefined;
+    for (const candidate of nodeIdMapCollection.contextNodeById.values()) {
+        if (candidate.tokenIndexStart < tokenIndexLowBound) {
+            continue;
+        }
+        if (closestContextOnOrAfterPosition === undefined ||
+            candidate.tokenIndexStart > closestContextOnOrAfterPosition.tokenIndexStart ||
+            findDepth(nodeIdMapCollection.parentIdById, candidate.id, depthCache) >
+                findDepth(nodeIdMapCollection.parentIdById, closestContextOnOrAfterPosition.id, depthCache)) {
+            closestContextOnOrAfterPosition = candidate;
+        }
+    }
+    return closestContextOnOrAfterPosition;
+}
+function findDepth(parentIdById, nodeId, depthCache) {
+    const cachedDepth = depthCache.get(nodeId);
+    if (cachedDepth !== undefined) {
+        return cachedDepth;
+    }
+    const parentId = parentIdById.get(nodeId);
+    if (parentId === undefined) {
+        return 0;
+    }
+    const summedDepth = 1 + findDepth(parentIdById, parentId, depthCache);
+    depthCache.set(nodeId, summedDepth);
+    return summedDepth;
+}
+function findLeafIdentifier(nodeIdMapCollection, leafXorNode) {
+    if (parser_1.XorNodeUtils.isContext(leafXorNode)) {
+        return undefined;
+    }
+    const leaf = leafXorNode.node;
+    let identifier;
+    const parentId = nodeIdMapCollection.parentIdById.get(leaf.id);
+    if (leaf.kind === language_1.Ast.NodeKind.Identifier) {
+        if (parentId === undefined) {
+            identifier = leaf;
+        }
+        else {
+            const parent = parser_1.NodeIdMapUtils.ast(nodeIdMapCollection, parentId);
+            if (parent?.kind === language_1.Ast.NodeKind.IdentifierPairedExpression) {
+                identifier = leaf;
+            }
+            else if (parent?.kind === language_1.Ast.NodeKind.IdentifierExpression) {
+                identifier = parent;
+            }
+            else {
+                identifier = leaf;
+            }
+        }
+    }
+    // If '@', then check if it's part of an IdentifierExpression.
+    else if (leaf.kind === language_1.Ast.NodeKind.Constant && leaf.constantKind === language_1.Constant.MiscConstant.AtSign) {
+        if (parentId === undefined) {
+            return undefined;
+        }
+        const parent = parser_1.NodeIdMapUtils.ast(nodeIdMapCollection, parentId);
+        if (parent?.kind === language_1.Ast.NodeKind.IdentifierExpression) {
+            identifier = parent;
+        }
+        else {
+            return undefined;
+        }
+    }
+    else if (leaf.kind === language_1.Ast.NodeKind.GeneralizedIdentifier) {
+        identifier = leaf;
+    }
+    else {
+        return undefined;
+    }
+    let result;
+    switch (identifier.kind) {
+        case language_1.Ast.NodeKind.Identifier:
+        case language_1.Ast.NodeKind.GeneralizedIdentifier:
+            result = {
+                node: identifier,
+                isRecursive: false,
+                normalizedLiteral: language_1.IdentifierUtils.assertNormalizedIdentifier(identifier.literal, {
+                    allowGeneralizedIdentifier: identifier.kind === language_1.Ast.NodeKind.GeneralizedIdentifier,
+                }),
+                normalizedRecursiveLiteral: undefined,
+            };
+            break;
+        case language_1.Ast.NodeKind.IdentifierExpression: {
+            const normalizedLiteral = language_1.IdentifierUtils.assertNormalizedIdentifier(identifier.identifier.literal, { allowGeneralizedIdentifier: false });
+            result = {
+                node: identifier,
+                normalizedLiteral,
+                normalizedRecursiveLiteral: identifier.inclusiveConstant ? `@${normalizedLiteral}` : undefined,
+            };
+            break;
+        }
+        default:
+            throw powerquery_parser_1.Assert.isNever(identifier);
+    }
+    return result;
+}
+function isInKey(ancestry) {
+    if (ancestry.length < 2) {
+        return false;
+    }
+    const child = powerquery_parser_1.ArrayUtils.assertGet(ancestry, 0);
+    const parent = powerquery_parser_1.ArrayUtils.assertGet(ancestry, 1);
+    // Return true if we're in the key portion of a key-value pair.
+    return ([
+        language_1.Ast.NodeKind.GeneralizedIdentifierPairedAnyLiteral,
+        language_1.Ast.NodeKind.GeneralizedIdentifierPairedExpression,
+        language_1.Ast.NodeKind.IdentifierPairedExpression,
+    ].includes(parent.node.kind) && child.node.attributeIndex === 0);
+}
 //# sourceMappingURL=activeNodeUtils.js.map