@tslite/services 0.0.0-stage → 1.12.0

package/dist/findAllReferences.js

@@ -0,0 +1,1366 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/findAllReferences.ts: o namespace virou módulo ES, com os imports explícitos.
+// O arquivo entra com o que os serviços que já vieram usam (o núcleo das referências, para os highlights); o resto dele vem
+// com o grupo que o usa (o docs/ARCHITECTURE.md do pacote).
+import { CheckFlags, Debug, InternalSymbolName, NodeFlags, ScriptTarget, SymbolDisplay, SymbolDisplayPartKind, SymbolFlags, SyntaxKind, addToSeen, append, arrayToSet, climbPastPropertyAccess, compareValues, contains, createMap, createTextSpan, createTextSpanFromBounds, displayPart, emptyArray, emptyOptions, escapeLeadingUnderscores, find, findAncestor, findIndex, first, firstDefined, firstOrUndefined, flatMap, forEachReturnStatement, getAdjustedReferenceLocation, getAdjustedRenameLocation, getCheckFlags, getContainerNode, getContainingObjectLiteralElement, getDeclarationFromName, getDeclarationOfKind, getMeaningFromDeclaration, getMeaningFromLocation, getNameOfDeclaration, getNameTable, getNodeId, getNodeKind, getPropertySymbolFromBindingElement, getPropertySymbolsFromContextualType, getSymbolId, getTextOfNode, getTouchingPropertyName, hasInitializer, hasType, isArrayLiteralOrObjectLiteralDestructuringPattern, isAssertionExpression, isBinaryExpression, isBindingElement, isBreakOrContinueStatement, isCallExpression, isCatchClause, isComputedPropertyName, isDeclaration, isDeclarationName, isExportAssignment, isExportSpecifier, isExpressionStatement, isExternalModuleSymbol, isExternalOrCommonJsModule, isForInOrOfStatement, isFunctionLike, isFunctionLikeDeclaration, isIdentifier, isIdentifierPart, isImportOrExportSpecifier, isImportSpecifier, isInNonReferenceComment, isInString, isJsxClosingElement, isJsxOpeningElement, isJsxSelfClosingElement, isLiteralComputedPropertyDeclarationName, isLiteralNameOfPropertyDeclarationOrIndexAccess, isModuleDeclaration, isObjectBindingElementWithoutPropertyName, isQualifiedName, isShorthandPropertyAssignment, isSourceFile, isStatement, isStringLiteral, isStringLiteralLike, isTypeAliasDeclaration, isTypeElement, isTypeKeyword, isTypeLiteralNode, isTypeNode, isTypeOperatorNode, isUnionTypeNode, isVariableDeclarationList, isVariableLike, isVariableStatement, isWriteAccess, map, mapDefined, nodeSeenTracker, punctuationPart, stripQuotes, symbolName, textPart, tokenToString, tryGetImportFromModuleSpecifier, } from "./_namespaces/ts.js";
+import { createImportTracker, findModuleReferences, getExportInfo, getImportOrExportSymbol, } from "./_namespaces/ts.FindAllReferences.js";
+/** Na tag, também o label e o `this` (CK-02). */
+export var DefinitionKind;
+(function (DefinitionKind) {
+    DefinitionKind[DefinitionKind["Symbol"] = 0] = "Symbol";
+    DefinitionKind[DefinitionKind["Keyword"] = 1] = "Keyword";
+    DefinitionKind[DefinitionKind["String"] = 2] = "String";
+})(DefinitionKind || (DefinitionKind = {}));
+export var EntryKind;
+(function (EntryKind) {
+    EntryKind[EntryKind["Span"] = 0] = "Span";
+    EntryKind[EntryKind["Node"] = 1] = "Node";
+    EntryKind[EntryKind["StringLiteral"] = 2] = "StringLiteral";
+    EntryKind[EntryKind["SearchedLocalFoundProperty"] = 3] = "SearchedLocalFoundProperty";
+    EntryKind[EntryKind["SearchedPropertyFoundLocal"] = 4] = "SearchedPropertyFoundLocal";
+})(EntryKind || (EntryKind = {}));
+export function nodeEntry(node, kind = 1 /* EntryKind.Node */) {
+    return {
+        kind,
+        node: node.name || node,
+        context: getContextNodeForNodeEntry(node)
+    };
+}
+export function isContextWithStartAndEndNode(node) {
+    return node && node.kind === undefined;
+}
+function getContextNodeForNodeEntry(node) {
+    if (isDeclaration(node)) {
+        return getContextNode(node);
+    }
+    if (!node.parent)
+        return undefined;
+    if (!isDeclaration(node.parent) && !isExportAssignment(node.parent)) {
+        // Na tag, também a atribuição especial de um arquivo JavaScript (CK-03).
+        // Jsx Tags
+        if (isJsxOpeningElement(node.parent) || isJsxClosingElement(node.parent)) {
+            return node.parent.parent;
+        }
+        // Na tag, também o statement com label (CK-02).
+        else if (isJsxSelfClosingElement(node.parent) ||
+            isBreakOrContinueStatement(node.parent)) {
+            return node.parent;
+        }
+        else if (isStringLiteralLike(node)) {
+            const validImport = tryGetImportFromModuleSpecifier(node);
+            if (validImport) {
+                // Na tag, também a tag do JSDoc em que o import de tipo estava (CK-03).
+                const declOrStatement = findAncestor(validImport, node => isDeclaration(node) ||
+                    isStatement(node));
+                return isDeclaration(declOrStatement) ?
+                    getContextNode(declOrStatement) :
+                    declOrStatement;
+            }
+        }
+        // Handle computed property name
+        const propertyName = findAncestor(node, isComputedPropertyName);
+        return propertyName ?
+            getContextNode(propertyName.parent) :
+            undefined;
+    }
+    // Na tag, também o construtor e o `default` de uma declaração exportada (CK-02).
+    if (node.parent.name === node || // node is name of declaration, use parent
+        isExportAssignment(node.parent) ||
+        // Property name of the import export specifier or binding pattern, use parent
+        ((isImportOrExportSpecifier(node.parent) || isBindingElement(node.parent))
+            && node.parent.propertyName === node)) {
+        return getContextNode(node.parent);
+    }
+    return undefined;
+}
+export function getContextNode(node) {
+    if (!node)
+        return undefined;
+    switch (node.kind) {
+        case SyntaxKind.VariableDeclaration:
+            return !isVariableDeclarationList(node.parent) || node.parent.declarations.length !== 1 ?
+                node :
+                isVariableStatement(node.parent.parent) ?
+                    node.parent.parent :
+                    isForInOrOfStatement(node.parent.parent) ?
+                        getContextNode(node.parent.parent) :
+                        node.parent;
+        case SyntaxKind.BindingElement:
+            return getContextNode(node.parent.parent);
+        case SyntaxKind.ImportSpecifier:
+            return node.parent.parent.parent;
+        case SyntaxKind.ExportSpecifier:
+        case SyntaxKind.NamespaceImport:
+            return node.parent.parent;
+        case SyntaxKind.ImportClause:
+            return node.parent;
+        case SyntaxKind.BinaryExpression:
+            return isExpressionStatement(node.parent) ?
+                node.parent :
+                node;
+        case SyntaxKind.ForOfStatement:
+        case SyntaxKind.ForInStatement:
+            return {
+                start: node.initializer,
+                end: node.expression
+            };
+        case SyntaxKind.PropertyAssignment:
+        case SyntaxKind.ShorthandPropertyAssignment:
+            return isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent) ?
+                getContextNode(findAncestor(node.parent, node => isBinaryExpression(node) || isForInOrOfStatement(node))) :
+                node;
+        default:
+            return node;
+    }
+}
+export function toContextSpan(textSpan, sourceFile, context) {
+    if (!context)
+        return undefined;
+    const contextSpan = isContextWithStartAndEndNode(context) ?
+        getTextSpan(context.start, sourceFile, context.end) :
+        getTextSpan(context, sourceFile);
+    return contextSpan.start !== textSpan.start || contextSpan.length !== textSpan.length ?
+        { contextSpan } :
+        undefined;
+}
+export var FindReferencesUse;
+(function (FindReferencesUse) {
+    /**
+     * When searching for references to a symbol, the location will not be adjusted (this is the default behavior when not specified).
+     */
+    FindReferencesUse[FindReferencesUse["Other"] = 0] = "Other";
+    /**
+     * When searching for references to a symbol, the location will be adjusted if the cursor was on a keyword.
+     */
+    FindReferencesUse[FindReferencesUse["References"] = 1] = "References";
+    /**
+     * When searching for references to a symbol, the location will be adjusted if the cursor was on a keyword.
+     * Unlike `References`, the location will only be adjusted keyword belonged to a declaration with a valid name.
+     * If set, we will find fewer references -- if it is referenced by several different names, we still only find references for the original name.
+     */
+    FindReferencesUse[FindReferencesUse["Rename"] = 2] = "Rename";
+})(FindReferencesUse || (FindReferencesUse = {}));
+export function findReferencedSymbols(program, cancellationToken, sourceFiles, sourceFile, position) {
+    const node = getTouchingPropertyName(sourceFile, position);
+    const referencedSymbols = Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, { use: 1 /* FindReferencesUse.References */ });
+    const checker = program.getTypeChecker();
+    return !referencedSymbols || !referencedSymbols.length ? undefined : mapDefined(referencedSymbols, ({ definition, references }) => 
+    // Only include referenced symbols that have a valid definition.
+    definition && {
+        definition: checker.runWithCancellationToken(cancellationToken, checker => definitionToReferencedSymbolDefinitionInfo(definition, checker, node)),
+        references: references.map(toReferenceEntry)
+    });
+}
+export function getImplementationsAtPosition(program, cancellationToken, sourceFiles, sourceFile, position) {
+    const node = getTouchingPropertyName(sourceFile, position);
+    let referenceEntries;
+    const entries = getImplementationReferenceEntries(program, cancellationToken, sourceFiles, node, position);
+    // Na tag, também o `super` (CK-02).
+    if (node.parent.kind === SyntaxKind.PropertyAccessExpression
+        || node.parent.kind === SyntaxKind.BindingElement
+        || node.parent.kind === SyntaxKind.ElementAccessExpression) {
+        referenceEntries = entries && [...entries];
+    }
+    else {
+        const queue = entries && [...entries];
+        const seenNodes = createMap();
+        while (queue && queue.length) {
+            const entry = queue.shift();
+            if (!addToSeen(seenNodes, getNodeId(entry.node))) {
+                continue;
+            }
+            referenceEntries = append(referenceEntries, entry);
+            const entries = getImplementationReferenceEntries(program, cancellationToken, sourceFiles, entry.node, entry.node.pos);
+            if (entries) {
+                queue.push(...entries);
+            }
+        }
+    }
+    const checker = program.getTypeChecker();
+    return map(referenceEntries, entry => toImplementationLocation(entry, checker));
+}
+function getImplementationReferenceEntries(program, cancellationToken, sourceFiles, node, position) {
+    if (node.kind === SyntaxKind.SourceFile) {
+        return undefined;
+    }
+    const checker = program.getTypeChecker();
+    // If invoked directly on a shorthand property assignment, then return
+    // the declaration of the symbol being assigned (not the symbol being assigned to).
+    if (node.parent.kind === SyntaxKind.ShorthandPropertyAssignment) {
+        const result = [];
+        Core.getReferenceEntriesForShorthandPropertyAssignment(node, checker, node => result.push(nodeEntry(node)));
+        return result;
+    }
+    // Na tag, o `super` e o acesso a partir dele davam a única implementação, a declaração do símbolo (CK-02).
+    else {
+        // Perform "Find all References" and retrieve only those that are implementations
+        return getReferenceEntriesForNode(position, node, program, sourceFiles, cancellationToken, { implementations: true, use: 1 /* FindReferencesUse.References */ });
+    }
+}
+export function findReferenceOrRenameEntries(program, cancellationToken, sourceFiles, node, position, options, convertEntry) {
+    return map(flattenEntries(Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options)), entry => convertEntry(entry, node, program.getTypeChecker()));
+}
+export function getReferenceEntriesForNode(position, node, program, sourceFiles, cancellationToken, options = {}, sourceFilesSet = arrayToSet(sourceFiles, f => f.fileName)) {
+    return flattenEntries(Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options, sourceFilesSet));
+}
+function flattenEntries(referenceSymbols) {
+    return referenceSymbols && flatMap(referenceSymbols, r => r.references);
+}
+function definitionToReferencedSymbolDefinitionInfo(def, checker, originalNode) {
+    const info = (() => {
+        switch (def.type) {
+            case 0 /* DefinitionKind.Symbol */: {
+                const { symbol } = def;
+                const { displayParts, kind } = getDefinitionKindAndDisplayParts(symbol, checker, originalNode);
+                const name = displayParts.map(p => p.text).join("");
+                const declaration = symbol.declarations ? first(symbol.declarations) : undefined;
+                return {
+                    node: declaration ?
+                        getNameOfDeclaration(declaration) || declaration :
+                        originalNode,
+                    name,
+                    kind,
+                    displayParts,
+                    context: getContextNode(declaration)
+                };
+            }
+            // Na tag, também o label e o `this` (CK-02).
+            case 1 /* DefinitionKind.Keyword */: {
+                const { node } = def;
+                const name = tokenToString(node.kind);
+                return { node, name, kind: "keyword" /* ScriptElementKind.keyword */, displayParts: [{ text: name, kind: "keyword" /* ScriptElementKind.keyword */ }] };
+            }
+            case 2 /* DefinitionKind.String */: {
+                const { node } = def;
+                return { node, name: node.text, kind: "var" /* ScriptElementKind.variableElement */, displayParts: [displayPart(getTextOfNode(node), SymbolDisplayPartKind.stringLiteral)] };
+            }
+            default:
+                return Debug.assertNever(def);
+        }
+    })();
+    const { node, name, kind, displayParts, context } = info;
+    const sourceFile = node.getSourceFile();
+    const textSpan = getTextSpan(isComputedPropertyName(node) ? node.expression : node, sourceFile);
+    return {
+        containerKind: "" /* ScriptElementKind.unknown */,
+        containerName: "",
+        fileName: sourceFile.fileName,
+        kind,
+        name,
+        textSpan,
+        displayParts,
+        ...toContextSpan(textSpan, sourceFile, context)
+    };
+}
+function getDefinitionKindAndDisplayParts(symbol, checker, node) {
+    const meaning = Core.getIntersectingMeaningFromDeclarations(node, symbol);
+    const enclosingDeclaration = symbol.declarations && firstOrUndefined(symbol.declarations) || node;
+    const { displayParts, symbolKind } = SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, enclosingDeclaration.getSourceFile(), enclosingDeclaration, enclosingDeclaration, meaning);
+    return { displayParts, kind: symbolKind };
+}
+export function toRenameLocation(entry, originalNode, checker, providePrefixAndSuffixText) {
+    return { ...entryToDocumentSpan(entry), ...(providePrefixAndSuffixText && getPrefixAndSuffixText(entry, originalNode, checker)) };
+}
+export function toReferenceEntry(entry) {
+    const documentSpan = entryToDocumentSpan(entry);
+    if (entry.kind === 0 /* EntryKind.Span */) {
+        return { ...documentSpan, isWriteAccess: false, isDefinition: false };
+    }
+    const { kind, node } = entry;
+    return {
+        ...documentSpan,
+        isWriteAccess: isWriteAccessForReference(node),
+        isDefinition: isDefinitionForReference(node),
+        isInString: kind === 2 /* EntryKind.StringLiteral */ ? true : undefined,
+    };
+}
+function entryToDocumentSpan(entry) {
+    if (entry.kind === 0 /* EntryKind.Span */) {
+        return { textSpan: entry.textSpan, fileName: entry.fileName };
+    }
+    else {
+        const sourceFile = entry.node.getSourceFile();
+        const textSpan = getTextSpan(entry.node, sourceFile);
+        return {
+            textSpan,
+            fileName: sourceFile.fileName,
+            ...toContextSpan(textSpan, sourceFile, entry.context)
+        };
+    }
+}
+function getPrefixAndSuffixText(entry, originalNode, checker) {
+    if (entry.kind !== 0 /* EntryKind.Span */ && isIdentifier(originalNode)) {
+        const { node, kind } = entry;
+        const name = originalNode.text;
+        const isShorthandAssignment = isShorthandPropertyAssignment(node.parent);
+        if (isShorthandAssignment || isObjectBindingElementWithoutPropertyName(node.parent) && node.parent.name === node) {
+            const prefixColon = { prefixText: name + ": " };
+            const suffixColon = { suffixText: ": " + name };
+            return kind === 3 /* EntryKind.SearchedLocalFoundProperty */ ? prefixColon
+                : kind === 4 /* EntryKind.SearchedPropertyFoundLocal */ ? suffixColon
+                    // In `const o = { x }; o.x`, symbolAtLocation at `x` in `{ x }` is the property symbol.
+                    // For a binding element `const { x } = o;`, symbolAtLocation at `x` is the property symbol.
+                    : isShorthandAssignment ? suffixColon : prefixColon;
+        }
+        else if (isImportSpecifier(entry.node.parent) && !entry.node.parent.propertyName) {
+            // If the original symbol was using this alias, just rename the alias.
+            const originalSymbol = isExportSpecifier(originalNode.parent) ? checker.getExportSpecifierLocalTargetSymbol(originalNode.parent) : checker.getSymbolAtLocation(originalNode);
+            return contains(originalSymbol.declarations, entry.node.parent) ? { prefixText: name + " as " } : emptyOptions;
+        }
+        else if (isExportSpecifier(entry.node.parent) && !entry.node.parent.propertyName) {
+            // If the symbol for the node is same as declared node symbol use prefix text
+            return originalNode === entry.node || checker.getSymbolAtLocation(originalNode) === checker.getSymbolAtLocation(entry.node) ?
+                { prefixText: name + " as " } :
+                { suffixText: " as " + name };
+        }
+    }
+    return emptyOptions;
+}
+function toImplementationLocation(entry, checker) {
+    const documentSpan = entryToDocumentSpan(entry);
+    if (entry.kind !== 0 /* EntryKind.Span */) {
+        const { node } = entry;
+        return {
+            ...documentSpan,
+            ...implementationKindDisplayParts(node, checker)
+        };
+    }
+    else {
+        return { ...documentSpan, kind: "" /* ScriptElementKind.unknown */, displayParts: [] };
+    }
+}
+function implementationKindDisplayParts(node, checker) {
+    const symbol = checker.getSymbolAtLocation(isDeclaration(node) && node.name ? node.name : node);
+    if (symbol) {
+        return getDefinitionKindAndDisplayParts(symbol, checker, node);
+    }
+    else if (node.kind === SyntaxKind.ObjectLiteralExpression) {
+        return {
+            kind: "interface" /* ScriptElementKind.interfaceElement */,
+            displayParts: [punctuationPart(SyntaxKind.OpenParenToken), textPart("object literal"), punctuationPart(SyntaxKind.CloseParenToken)]
+        };
+    }
+    // Na tag, também a class expression anônima (CK-02).
+    else {
+        return { kind: getNodeKind(node), displayParts: [] };
+    }
+}
+export function toHighlightSpan(entry) {
+    const documentSpan = entryToDocumentSpan(entry);
+    if (entry.kind === 0 /* EntryKind.Span */) {
+        return {
+            fileName: documentSpan.fileName,
+            span: {
+                textSpan: documentSpan.textSpan,
+                kind: "reference" /* HighlightSpanKind.reference */
+            }
+        };
+    }
+    const writeAccess = isWriteAccessForReference(entry.node);
+    const span = {
+        textSpan: documentSpan.textSpan,
+        kind: writeAccess ? "writtenReference" /* HighlightSpanKind.writtenReference */ : "reference" /* HighlightSpanKind.reference */,
+        isInString: entry.kind === 2 /* EntryKind.StringLiteral */ ? true : undefined,
+        ...documentSpan.contextSpan && { contextSpan: documentSpan.contextSpan }
+    };
+    return { fileName: documentSpan.fileName, span };
+}
+function getTextSpan(node, sourceFile, endNode) {
+    let start = node.getStart(sourceFile);
+    let end = (endNode || node).getEnd();
+    if (isStringLiteralLike(node)) {
+        Debug.assert(endNode === undefined);
+        start += 1;
+        end -= 1;
+    }
+    return createTextSpanFromBounds(start, end);
+}
+export function getTextSpanOfEntry(entry) {
+    return entry.kind === 0 /* EntryKind.Span */ ? entry.textSpan :
+        getTextSpan(entry.node, entry.node.getSourceFile());
+}
+/** A node is considered a writeAccess iff it is a name of a declaration or a target of an assignment */
+function isWriteAccessForReference(node) {
+    const decl = getDeclarationFromName(node);
+    return !!decl && declarationIsWriteAccess(decl) || node.kind === SyntaxKind.DefaultKeyword || isWriteAccess(node);
+}
+/** Na tag, também o `constructor` da declaração do construtor (CK-02). */
+function isDefinitionForReference(node) {
+    return node.kind === SyntaxKind.DefaultKeyword
+        || !!getDeclarationFromName(node)
+        || isLiteralComputedPropertyDeclarationName(node);
+}
+/**
+ * True if 'decl' provides a value, as in `const f = () => {}`;
+ * false if 'decl' is just a location for a future write, as in 'let x;'
+ * Na tag, também a classe, o enum e o membro dele, a interface e a `function`, o construtor, o método, o acessor, a
+ * propriedade de classe e a method signature (CK-02, CK-36), o `import =` e o `export as namespace`, e as tags do JSDoc
+ * (CK-03).
+ */
+function declarationIsWriteAccess(decl) {
+    // Consider anything in an ambient declaration to be a write access since it may be coming from JS.
+    if (!!(decl.flags & NodeFlags.Ambient))
+        return true;
+    switch (decl.kind) {
+        case SyntaxKind.BinaryExpression:
+        case SyntaxKind.BindingElement:
+        case SyntaxKind.DefaultKeyword:
+        case SyntaxKind.ExportSpecifier:
+        case SyntaxKind.ImportClause: // default import
+        case SyntaxKind.ImportSpecifier:
+        case SyntaxKind.JsxAttribute:
+        case SyntaxKind.ModuleDeclaration:
+        case SyntaxKind.NamespaceImport:
+        case SyntaxKind.NamespaceExport:
+        case SyntaxKind.Parameter:
+        case SyntaxKind.ShorthandPropertyAssignment:
+        case SyntaxKind.TypeAliasDeclaration:
+        case SyntaxKind.TypeParameter:
+            return true;
+        case SyntaxKind.PropertyAssignment:
+            // In `({ x: y } = 0);`, `x` is not a write access. (Won't call this function for `y`.)
+            return !isArrayLiteralOrObjectLiteralDestructuringPattern(decl.parent);
+        case SyntaxKind.VariableDeclaration:
+            return !!decl.initializer || isCatchClause(decl.parent);
+        case SyntaxKind.PropertySignature:
+            return false;
+        default:
+            return Debug.failBadSyntaxKind(decl);
+    }
+}
+/** Encapsulates the core find-all-references algorithm. */
+export var Core;
+(function (Core) {
+    /** Core find-all-references algorithm. Handles special cases before delegating to `getReferencedSymbolsForSymbol`. */
+    function getReferencedSymbolsForNode(_position, node, program, sourceFiles, cancellationToken, options = {}, sourceFilesSet = arrayToSet(sourceFiles, f => f.fileName)) {
+        if (options.use === 1 /* FindReferencesUse.References */) {
+            node = getAdjustedReferenceLocation(node);
+        }
+        else if (options.use === 2 /* FindReferencesUse.Rename */) {
+            node = getAdjustedRenameLocation(node);
+        }
+        // Na tag, no arquivo, a referência `/// <reference …>` na posição dava as referências ao arquivo referido (o
+        // `GoToDefinition.getReferenceAtPosition`); a referência por texto saiu (CK-03).
+        if (isSourceFile(node)) {
+            return undefined;
+        }
+        if (!options.implementations) {
+            const special = getReferencedSymbolsSpecial(node, sourceFiles, cancellationToken);
+            if (special) {
+                return special;
+            }
+        }
+        const checker = program.getTypeChecker();
+        const symbol = checker.getSymbolAtLocation(node);
+        // Could not find a symbol e.g. unknown identifier
+        if (!symbol) {
+            // String literal might be a property (and thus have a symbol), so do this here rather than in getReferencedSymbolsSpecial.
+            return !options.implementations && isStringLiteral(node) ? getReferencesForStringLiteral(node, sourceFiles, cancellationToken) : undefined;
+        }
+        // Na tag, o símbolo `export=` dava as referências ao módulo (CK-03).
+        const moduleReferences = getReferencedSymbolsForModuleIfDeclaredBySourceFile(symbol, program, sourceFiles, sourceFilesSet);
+        if (moduleReferences && !(symbol.flags & SymbolFlags.Transient)) {
+            return moduleReferences;
+        }
+        // Na tag, também as referências ao módulo do `export as namespace` de um UMD (CK-03).
+        const references = getReferencedSymbolsForSymbol(symbol, node, sourceFiles, sourceFilesSet, checker, cancellationToken, options);
+        return mergeReferences(program, moduleReferences, references);
+    }
+    Core.getReferencedSymbolsForNode = getReferencedSymbolsForNode;
+    /** Na tag, também as referências ao valor do `export =` do módulo (CK-03). */
+    function getReferencedSymbolsForModuleIfDeclaredBySourceFile(symbol, program, sourceFiles, sourceFilesSet) {
+        const moduleSourceFile = (symbol.flags & SymbolFlags.Module) && symbol.declarations && find(symbol.declarations, isSourceFile);
+        if (!moduleSourceFile)
+            return undefined;
+        return getReferencedSymbolsForModule(program, symbol, sourceFiles, sourceFilesSet);
+    }
+    /**
+     * Merges the references by sorting them (by file index in sourceFiles and their location in it) that point to same definition symbol
+     */
+    function mergeReferences(program, ...referencesToMerge) {
+        let result;
+        for (const references of referencesToMerge) {
+            if (!references || !references.length)
+                continue;
+            if (!result) {
+                result = references;
+                continue;
+            }
+            for (const entry of references) {
+                if (!entry.definition || entry.definition.type !== 0 /* DefinitionKind.Symbol */) {
+                    result.push(entry);
+                    continue;
+                }
+                const symbol = entry.definition.symbol;
+                const refIndex = findIndex(result, ref => !!ref.definition &&
+                    ref.definition.type === 0 /* DefinitionKind.Symbol */ &&
+                    ref.definition.symbol === symbol);
+                if (refIndex === -1) {
+                    result.push(entry);
+                    continue;
+                }
+                const reference = result[refIndex];
+                result[refIndex] = {
+                    definition: reference.definition,
+                    references: reference.references.concat(entry.references).sort((entry1, entry2) => {
+                        const entry1File = getSourceFileIndexOfEntry(program, entry1);
+                        const entry2File = getSourceFileIndexOfEntry(program, entry2);
+                        if (entry1File !== entry2File) {
+                            return compareValues(entry1File, entry2File);
+                        }
+                        const entry1Span = getTextSpanOfEntry(entry1);
+                        const entry2Span = getTextSpanOfEntry(entry2);
+                        return entry1Span.start !== entry2Span.start ?
+                            compareValues(entry1Span.start, entry2Span.start) :
+                            compareValues(entry1Span.length, entry2Span.length);
+                    })
+                };
+            }
+        }
+        return result;
+    }
+    function getSourceFileIndexOfEntry(program, entry) {
+        const sourceFile = entry.kind === 0 /* EntryKind.Span */ ?
+            program.getSourceFile(entry.fileName) :
+            entry.node.getSourceFile();
+        return program.getSourceFiles().indexOf(sourceFile);
+    }
+    /**
+     * As referências a um módulo: os imports dele e as declarações. Na tag, também a referência `/// <reference …>` ao
+     * arquivo, o valor do `export =` e o `module.exports` (CK-03).
+     */
+    function getReferencedSymbolsForModule(program, symbol, sourceFiles, _sourceFilesSet) {
+        Debug.assert(!!symbol.valueDeclaration);
+        const references = mapDefined(findModuleReferences(program, sourceFiles, symbol), reference => nodeEntry(reference.literal));
+        if (symbol.declarations) {
+            for (const decl of symbol.declarations) {
+                switch (decl.kind) {
+                    case SyntaxKind.SourceFile:
+                        // Don't include the source file itself. (This may not be ideal behavior, but awkward to include an entire file as a reference.)
+                        break;
+                    // Na tag, também o `declare module "x"` que aumentava o módulo (CK-02).
+                    default:
+                        // This may be merged with something.
+                        Debug.assert(!!(symbol.flags & SymbolFlags.Transient), "Expected a module symbol to be declared by a SourceFile or ModuleDeclaration.");
+                }
+            }
+        }
+        return references.length ? [{ definition: { type: 0 /* DefinitionKind.Symbol */, symbol }, references }] : emptyArray;
+    }
+    /** As in a `readonly prop: any` or `constructor(readonly prop: any)`, not a `readonly any[]`. */
+    function isReadonlyTypeOperator(node) {
+        return node.kind === SyntaxKind.ReadonlyKeyword
+            && isTypeOperatorNode(node.parent)
+            && node.parent.operator === SyntaxKind.ReadonlyKeyword;
+    }
+    /**
+     * getReferencedSymbols for special node kinds. Na tag, também o label (CK-02), o `this` e o `super` (CK-02), e o
+     * `void` de uma expressão não era o tipo `void` (CK-63).
+     */
+    function getReferencedSymbolsSpecial(node, sourceFiles, cancellationToken) {
+        if (isTypeKeyword(node.kind)) {
+            // A modifier readonly (like on a property declaration) is not special;
+            // a readonly type keyword (like `readonly string[]`) is.
+            if (node.kind === SyntaxKind.ReadonlyKeyword && !isReadonlyTypeOperator(node)) {
+                return undefined;
+            }
+            // Likewise, when we *are* looking for a special keyword, make sure we
+            // *don’t* include readonly member modifiers.
+            return getAllReferencesForKeyword(sourceFiles, node.kind, cancellationToken, node.kind === SyntaxKind.ReadonlyKeyword ? isReadonlyTypeOperator : undefined);
+        }
+        return undefined;
+    }
+    /** Core find-all-references algorithm for a normal symbol. */
+    function getReferencedSymbolsForSymbol(originalSymbol, node, sourceFiles, sourceFilesSet, checker, cancellationToken, options) {
+        const symbol = node && skipPastExportOrImportSpecifierOrUnion(originalSymbol, node, checker, /*useLocalSymbolForExportSpecifier*/ !isForRenameWithPrefixAndSuffixText(options)) || originalSymbol;
+        // Compute the meaning from the location and the symbol it references
+        const searchMeaning = node ? getIntersectingMeaningFromDeclarations(node, symbol) : 7 /* SemanticMeaning.All */;
+        const result = [];
+        // Na tag, o nome de uma classe e o `constructor` davam uma busca especial (o `SpecialSearchKind`, CK-02).
+        const state = new State(sourceFiles, sourceFilesSet, checker, cancellationToken, searchMeaning, options, result);
+        const exportSpecifier = !isForRenameWithPrefixAndSuffixText(options) ? undefined : find(symbol.declarations, isExportSpecifier);
+        if (exportSpecifier) {
+            // When renaming at an export specifier, rename the export and not the thing being exported.
+            getReferencesAtExportSpecifier(exportSpecifier.name, symbol, exportSpecifier, state.createSearch(node, originalSymbol, /*comingFrom*/ undefined), state, /*addReferencesHere*/ true, /*alwaysGetReferences*/ true);
+        }
+        else if (node && node.kind === SyntaxKind.DefaultKeyword) {
+            addReference(node, symbol, state);
+            searchForImportsOfExport(node, symbol, { exportingModuleSymbol: Debug.checkDefined(symbol.parent, "Expected export symbol to have a parent"), exportKind: 1 /* ExportKind.Default */ }, state);
+        }
+        else {
+            const search = state.createSearch(node, symbol, /*comingFrom*/ undefined, { allSearchSymbols: node ? populateSearchSymbolSet(symbol, node, checker, options.use === 2 /* FindReferencesUse.Rename */, !!options.providePrefixAndSuffixTextForRename) : [symbol] });
+            getReferencesInContainerOrFiles(symbol, state, search);
+        }
+        return result;
+    }
+    function getReferencesInContainerOrFiles(symbol, state, search) {
+        // Try to get the smallest valid scope that we can limit our search to;
+        // otherwise we'll need to search globally (i.e. include each file).
+        const scope = getSymbolScope(symbol);
+        if (scope) {
+            getReferencesInContainer(scope, scope.getSourceFile(), search, state, /*addReferencesHere*/ !(isSourceFile(scope) && !contains(state.sourceFiles, scope)));
+        }
+        else {
+            // Global search
+            for (const sourceFile of state.sourceFiles) {
+                state.cancellationToken.throwIfCancellationRequested();
+                searchForName(sourceFile, search, state);
+            }
+        }
+    }
+    /** Handle a few special cases relating to export/import specifiers. */
+    function skipPastExportOrImportSpecifierOrUnion(symbol, node, checker, useLocalSymbolForExportSpecifier) {
+        const { parent } = node;
+        if (isExportSpecifier(parent) && useLocalSymbolForExportSpecifier) {
+            return getLocalSymbolForExportSpecifier(node, symbol, parent, checker);
+        }
+        // If the symbol is declared as part of a declaration like `{ type: "a" } | { type: "b" }`, use the property on the union type to get more references.
+        return firstDefined(symbol.declarations, decl => {
+            if (!decl.parent) {
+                // Ignore UMD module and global merge
+                if (symbol.flags & SymbolFlags.Transient)
+                    return undefined;
+                // Assertions for GH#21814. We should be handling SourceFile symbols in `getReferencedSymbolsForModule` instead of getting here.
+                Debug.fail(`Unexpected symbol at ${Debug.formatSyntaxKind(node.kind)}: ${Debug.formatSymbol(symbol)}`);
+            }
+            return isTypeLiteralNode(decl.parent) && isUnionTypeNode(decl.parent.parent)
+                ? checker.getPropertyOfType(checker.getTypeFromTypeNode(decl.parent.parent), symbol.name)
+                : undefined;
+        });
+    }
+    function getNonModuleSymbolOfMergedModuleSymbol(symbol) {
+        if (!(symbol.flags & (SymbolFlags.Module | SymbolFlags.Transient)))
+            return undefined;
+        const decl = symbol.declarations && find(symbol.declarations, d => !isSourceFile(d) && !isModuleDeclaration(d));
+        return decl && decl.symbol;
+    }
+    /**
+     * Holds all state needed for the finding references.
+     * Unlike `Search`, there is only one `State`.
+     */
+    class State {
+        constructor(sourceFiles, sourceFilesSet, checker, cancellationToken, searchMeaning, options, result) {
+            this.sourceFiles = sourceFiles;
+            this.sourceFilesSet = sourceFilesSet;
+            this.checker = checker;
+            this.cancellationToken = cancellationToken;
+            this.searchMeaning = searchMeaning;
+            this.options = options;
+            this.result = result;
+            /**
+             * Type nodes can contain multiple references to the same type. For example:
+             *      let x: Foo & (Foo & Bar) = ...
+             * Because we are returning the implementation locations and not the identifier locations,
+             * duplicate entries would be returned here as each of the type references is part of
+             * the same implementation. For that reason, check before we add a new entry.
+             */
+            this.markSeenContainingTypeReference = nodeSeenTracker();
+            /**
+             * It's possible that we will encounter the right side of `export { foo as bar } from "x";` more than once.
+             * For example:
+             *     // b.ts
+             *     export { foo as bar } from "./a";
+             *     import { bar } from "./b";
+             *
+             * Normally at `foo as bar` we directly add `foo` and do not locally search for it (since it doesn't declare a local).
+             * But another reference to it may appear in the same source file.
+             * See `tests/cases/fourslash/transitiveExportImports3.ts`.
+             */
+            this.markSeenReExportRHS = nodeSeenTracker();
+            this.symbolIdToReferences = [];
+            // Source file ID → symbol ID → Whether the symbol has been searched for in the source file.
+            this.sourceFileToSeenSymbols = [];
+        }
+        includesSourceFile(sourceFile) {
+            return this.sourceFilesSet.has(sourceFile.fileName);
+        }
+        /** Gets every place to look for references of an exported symbols. See `ImportsResult` in `importTracker.ts` for more documentation. */
+        getImportSearches(exportSymbol, exportInfo) {
+            if (!this.importTracker)
+                this.importTracker = createImportTracker(this.sourceFiles, this.sourceFilesSet, this.checker, this.cancellationToken);
+            return this.importTracker(exportSymbol, exportInfo, this.options.use === 2 /* FindReferencesUse.Rename */);
+        }
+        /** @param allSearchSymbols set of additional symbols for use by `includes`. */
+        createSearch(_location, symbol, comingFrom, searchOptions = {}) {
+            // Note: if this is an external module symbol, the name doesn't include quotes.
+            // Na tag, o `export default class C {}` dava o nome local `C` (o `getLocalSymbolForExportDefault`); o modificador
+            // `default` de uma declaração saiu com a classe e a `function` (CK-02).
+            const { text = stripQuotes(symbolName(getNonModuleSymbolOfMergedModuleSymbol(symbol) || symbol)), allSearchSymbols = [symbol], } = searchOptions;
+            const escapedText = escapeLeadingUnderscores(text);
+            return { symbol, comingFrom, text, escapedText, allSearchSymbols, includes: sym => contains(allSearchSymbols, sym) };
+        }
+        /**
+         * Callback to add references for a particular searched symbol.
+         * This initializes a reference group, so only call this if you will add at least one reference.
+         */
+        referenceAdder(searchSymbol) {
+            const symbolId = getSymbolId(searchSymbol);
+            let references = this.symbolIdToReferences[symbolId];
+            if (!references) {
+                references = this.symbolIdToReferences[symbolId] = [];
+                this.result.push({ definition: { type: 0 /* DefinitionKind.Symbol */, symbol: searchSymbol }, references });
+            }
+            return (node, kind) => references.push(nodeEntry(node, kind));
+        }
+        /** Add a reference with no associated definition. */
+        addStringOrCommentReference(fileName, textSpan) {
+            this.result.push({
+                definition: undefined,
+                references: [{ kind: 0 /* EntryKind.Span */, fileName, textSpan }]
+            });
+        }
+        /** Returns `true` the first time we search for a symbol in a file and `false` afterwards. */
+        markSearchedSymbols(sourceFile, symbols) {
+            const sourceId = getNodeId(sourceFile);
+            const seenSymbols = this.sourceFileToSeenSymbols[sourceId] || (this.sourceFileToSeenSymbols[sourceId] = createMap());
+            let anyNewSymbols = false;
+            for (const sym of symbols) {
+                anyNewSymbols = addToSeen(seenSymbols, getSymbolId(sym)) || anyNewSymbols;
+            }
+            return anyNewSymbols;
+        }
+    }
+    /** Search for all imports of a given exported symbol using `State.getImportSearches`. */
+    function searchForImportsOfExport(exportLocation, exportSymbol, exportInfo, state) {
+        const { importSearches, singleReferences, indirectUsers } = state.getImportSearches(exportSymbol, exportInfo);
+        // For `import { foo as bar }` just add the reference to `foo`, and don't otherwise search in the file.
+        if (singleReferences.length) {
+            const addRef = state.referenceAdder(exportSymbol);
+            for (const singleRef of singleReferences) {
+                if (shouldAddSingleReference(singleRef, state))
+                    addRef(singleRef);
+            }
+        }
+        // For each import, find all references to that import in its source file.
+        for (const [importLocation, importSymbol] of importSearches) {
+            getReferencesInSourceFile(importLocation.getSourceFile(), state.createSearch(importLocation, importSymbol, 1 /* ImportExport.Export */), state);
+        }
+        if (indirectUsers.length) {
+            let indirectSearch;
+            switch (exportInfo.exportKind) {
+                case 0 /* ExportKind.Named */:
+                    indirectSearch = state.createSearch(exportLocation, exportSymbol, 1 /* ImportExport.Export */);
+                    break;
+                case 1 /* ExportKind.Default */:
+                    // Search for a property access to '.default'. This can't be renamed.
+                    indirectSearch = state.options.use === 2 /* FindReferencesUse.Rename */ ? undefined : state.createSearch(exportLocation, exportSymbol, 1 /* ImportExport.Export */, { text: "default" });
+                    break;
+                // Na tag, também o `export =`, sem busca indireta (CK-03).
+            }
+            if (indirectSearch) {
+                for (const indirectUser of indirectUsers) {
+                    searchForName(indirectUser, indirectSearch, state);
+                }
+            }
+        }
+    }
+    function eachExportReference(sourceFiles, checker, cancellationToken, exportSymbol, exportingModuleSymbol, exportName, isDefaultExport, cb) {
+        const importTracker = createImportTracker(sourceFiles, arrayToSet(sourceFiles, f => f.fileName), checker, cancellationToken);
+        const { importSearches, indirectUsers } = importTracker(exportSymbol, { exportKind: isDefaultExport ? 1 /* ExportKind.Default */ : 0 /* ExportKind.Named */, exportingModuleSymbol }, /*isForRename*/ false);
+        for (const [importLocation] of importSearches) {
+            cb(importLocation);
+        }
+        for (const indirectUser of indirectUsers) {
+            for (const node of getPossibleSymbolReferenceNodes(indirectUser, isDefaultExport ? "default" : exportName)) {
+                // Import specifiers should be handled by importSearches
+                if (isIdentifier(node) && !isImportOrExportSpecifier(node.parent) && checker.getSymbolAtLocation(node) === exportSymbol) {
+                    cb(node);
+                }
+            }
+        }
+    }
+    Core.eachExportReference = eachExportReference;
+    function shouldAddSingleReference(singleRef, state) {
+        if (!hasMatchingMeaning(singleRef, state))
+            return false;
+        if (state.options.use !== 2 /* FindReferencesUse.Rename */)
+            return true;
+        // Don't rename an import type `import("./module-name")` when renaming `name` in `export = name;`
+        if (!isIdentifier(singleRef))
+            return false;
+        // At `default` in `import { default as x }` or `export { default as x }`, do add a reference, but do not rename.
+        return !(isImportOrExportSpecifier(singleRef.parent) && singleRef.escapedText === InternalSymbolName.Default);
+    }
+    // Go to the symbol we imported from and find references for it.
+    function searchForImportedSymbol(symbol, state) {
+        if (!symbol.declarations)
+            return;
+        for (const declaration of symbol.declarations) {
+            const exportingFile = declaration.getSourceFile();
+            // Need to search in the file even if it's not in the search-file set, because it might export the symbol.
+            getReferencesInSourceFile(exportingFile, state.createSearch(declaration, symbol, 0 /* ImportExport.Import */), state, state.includesSourceFile(exportingFile));
+        }
+    }
+    /** Search for all occurences of an identifier in a source file (and filter out the ones that match). */
+    function searchForName(sourceFile, search, state) {
+        if (getNameTable(sourceFile).get(search.escapedText) !== undefined) {
+            getReferencesInSourceFile(sourceFile, search, state);
+        }
+    }
+    function getPropertySymbolOfDestructuringAssignment(location, checker) {
+        return isArrayLiteralOrObjectLiteralDestructuringPattern(location.parent.parent)
+            ? checker.getPropertySymbolOfDestructuringAssignment(location)
+            : undefined;
+    }
+    /**
+     * Determines the smallest scope in which a symbol may have named references.
+     * Note that not every construct has been accounted for. This function can
+     * probably be improved.
+     *
+     * @returns undefined if the scope cannot be determined, implying that
+     * a reference to a symbol can occur anywhere.
+     */
+    function getSymbolScope(symbol) {
+        // Na tag, o nome de uma function expression ou de uma class expression tinha como escopo a própria expressão
+        // (CK-02).
+        const { declarations, flags, parent } = symbol;
+        if (!declarations) {
+            return undefined;
+        }
+        // A propriedade e o método são públicos, e podem ser acessados de qualquer lugar. Na tag, o escopo da propriedade
+        // ou do método privado era a classe dele (CK-02).
+        if (flags & (SymbolFlags.Property | SymbolFlags.Method)) {
+            return undefined;
+        }
+        // If symbol is of object binding pattern element without property name we would want to
+        // look for property too and that could be anywhere
+        if (declarations.some(isObjectBindingElementWithoutPropertyName)) {
+            return undefined;
+        }
+        /*
+        If the symbol has a parent, it's globally visible unless:
+        - It's a type parameter.
+        - The parent is an external module: then we should only search in the module (and recurse on the export later).
+        Na tag, também a propriedade privada, e o módulo com `export as namespace` expunha o símbolo de todo lugar (CK-02,
+        CK-03).
+        */
+        const exposedByParent = parent && !(symbol.flags & SymbolFlags.TypeParameter);
+        if (exposedByParent && !isExternalModuleSymbol(parent)) {
+            return undefined;
+        }
+        let scope;
+        for (const declaration of declarations) {
+            const container = getContainerNode(declaration);
+            if (scope && scope !== container) {
+                // Different declarations have different containers, bail out
+                return undefined;
+            }
+            if (!container || container.kind === SyntaxKind.SourceFile && !isExternalOrCommonJsModule(container)) {
+                // This is a global variable and not an external module, any declaration defined
+                // within this scope is visible outside the file
+                return undefined;
+            }
+            // The search scope is the container node
+            scope = container;
+        }
+        // If symbol.parent, this means we are in an export of an external module. (Otherwise we would have returned `undefined` above.)
+        // For an export of a module, we may be in a declaration file, and it may be accessed elsewhere. E.g.:
+        //     declare module "a" { export type T = number; }
+        //     declare module "b" { import { T } from "a"; export const x: T; }
+        // So we must search the whole source file. (Because we will mark the source file as seen, we we won't return to it when searching for imports.)
+        return exposedByParent ? scope.getSourceFile() : scope;
+    }
+    /** Used as a quick check for whether a symbol is used at all in a file (besides its definition). */
+    function isSymbolReferencedInFile(definition, checker, sourceFile, searchContainer = sourceFile) {
+        return eachSymbolReferenceInFile(definition, checker, sourceFile, () => true, searchContainer) || false;
+    }
+    Core.isSymbolReferencedInFile = isSymbolReferencedInFile;
+    function eachSymbolReferenceInFile(definition, checker, sourceFile, cb, searchContainer = sourceFile) {
+        // Na tag, o nome de uma parameter property dava o símbolo da propriedade (CK-02).
+        const symbol = checker.getSymbolAtLocation(definition);
+        if (!symbol)
+            return undefined;
+        for (const token of getPossibleSymbolReferenceNodes(sourceFile, symbol.name, searchContainer)) {
+            if (!isIdentifier(token) || token === definition || token.escapedText !== definition.escapedText)
+                continue;
+            const referenceSymbol = checker.getSymbolAtLocation(token); // See GH#19955 for why the type annotation is necessary
+            if (referenceSymbol === symbol
+                || checker.getShorthandAssignmentValueSymbol(token.parent) === symbol
+                || isExportSpecifier(token.parent) && getLocalSymbolForExportSpecifier(token, referenceSymbol, token.parent, checker) === symbol) {
+                const res = cb(token);
+                if (res)
+                    return res;
+            }
+        }
+    }
+    Core.eachSymbolReferenceInFile = eachSymbolReferenceInFile;
+    function eachSignatureCall(signature, sourceFiles, checker, cb) {
+        if (!signature.name || !isIdentifier(signature.name))
+            return;
+        const symbol = Debug.checkDefined(checker.getSymbolAtLocation(signature.name));
+        for (const sourceFile of sourceFiles) {
+            for (const name of getPossibleSymbolReferenceNodes(sourceFile, symbol.name)) {
+                if (!isIdentifier(name) || name === signature.name || name.escapedText !== signature.name.escapedText)
+                    continue;
+                const called = climbPastPropertyAccess(name);
+                const call = called.parent;
+                if (!isCallExpression(call) || call.expression !== called)
+                    continue;
+                const referenceSymbol = checker.getSymbolAtLocation(name);
+                if (referenceSymbol && checker.getRootSymbols(referenceSymbol).some(s => s === symbol)) {
+                    cb(call);
+                }
+            }
+        }
+    }
+    Core.eachSignatureCall = eachSignatureCall;
+    function getPossibleSymbolReferenceNodes(sourceFile, symbolName, container = sourceFile) {
+        return getPossibleSymbolReferencePositions(sourceFile, symbolName, container).map(pos => getTouchingPropertyName(sourceFile, pos));
+    }
+    function getPossibleSymbolReferencePositions(sourceFile, symbolName, container = sourceFile) {
+        const positions = [];
+        /// TODO: Cache symbol existence for files to save text search
+        // Also, need to make this work for unicode escapes.
+        // Be resilient in the face of a symbol with no name or zero length name
+        if (!symbolName || !symbolName.length) {
+            return positions;
+        }
+        const text = sourceFile.text;
+        const sourceLength = text.length;
+        const symbolNameLength = symbolName.length;
+        let position = text.indexOf(symbolName, container.pos);
+        while (position >= 0) {
+            // If we are past the end, stop looking
+            if (position > container.end)
+                break;
+            // We found a match.  Make sure it's not part of a larger word (i.e. the char
+            // before and after it have to be a non-identifier char).
+            const endPosition = position + symbolNameLength;
+            if ((position === 0 || !isIdentifierPart(text.charCodeAt(position - 1), ScriptTarget.Latest)) &&
+                (endPosition === sourceLength || !isIdentifierPart(text.charCodeAt(endPosition), ScriptTarget.Latest))) {
+                // Found a real match.  Keep searching.
+                positions.push(position);
+            }
+            position = text.indexOf(symbolName, position + symbolNameLength + 1);
+        }
+        return positions;
+    }
+    function isValidReferencePosition(node, searchSymbolName) {
+        // Compare the length so we filter out strict superstrings of the symbol we are looking for
+        // Na tag, também o nome `#private` (CK-02); e, no literal, o nome de um `declare module "x"` (CK-02), o `require` de
+        // um `import =` e o nome de propriedade do `Object.defineProperty` de um arquivo JavaScript (CK-03).
+        switch (node.kind) {
+            case SyntaxKind.Identifier:
+                return node.text.length === searchSymbolName.length;
+            case SyntaxKind.NoSubstitutionTemplateLiteral:
+            case SyntaxKind.StringLiteral: {
+                const str = node;
+                return isLiteralNameOfPropertyDeclarationOrIndexAccess(str) &&
+                    str.text.length === searchSymbolName.length;
+            }
+            case SyntaxKind.NumericLiteral:
+                return isLiteralNameOfPropertyDeclarationOrIndexAccess(node) && node.text.length === searchSymbolName.length;
+            case SyntaxKind.DefaultKeyword:
+                return "default".length === searchSymbolName.length;
+            default:
+                return false;
+        }
+    }
+    function getAllReferencesForKeyword(sourceFiles, keywordKind, cancellationToken, filter) {
+        const references = flatMap(sourceFiles, sourceFile => {
+            cancellationToken.throwIfCancellationRequested();
+            return mapDefined(getPossibleSymbolReferenceNodes(sourceFile, tokenToString(keywordKind), sourceFile), referenceLocation => {
+                if (referenceLocation.kind === keywordKind && (!filter || filter(referenceLocation))) {
+                    return nodeEntry(referenceLocation);
+                }
+            });
+        });
+        return references.length ? [{ definition: { type: 1 /* DefinitionKind.Keyword */, node: references[0].node }, references }] : undefined;
+    }
+    function getReferencesInSourceFile(sourceFile, search, state, addReferencesHere = true) {
+        state.cancellationToken.throwIfCancellationRequested();
+        return getReferencesInContainer(sourceFile, sourceFile, search, state, addReferencesHere);
+    }
+    /**
+     * Search within node "container" for references for a search value, where the search value is defined as a
+     * tuple of(searchSymbol, searchText, searchLocation, and searchMeaning).
+     * searchLocation: a node where the search value
+     */
+    function getReferencesInContainer(container, sourceFile, search, state, addReferencesHere) {
+        if (!state.markSearchedSymbols(sourceFile, search.allSearchSymbols)) {
+            return;
+        }
+        for (const position of getPossibleSymbolReferencePositions(sourceFile, search.text, container)) {
+            getReferencesAtLocation(sourceFile, position, search, state, addReferencesHere);
+        }
+    }
+    function hasMatchingMeaning(referenceLocation, state) {
+        return !!(getMeaningFromLocation(referenceLocation) & state.searchMeaning);
+    }
+    function getReferencesAtLocation(sourceFile, position, search, state, addReferencesHere) {
+        const referenceLocation = getTouchingPropertyName(sourceFile, position);
+        if (!isValidReferencePosition(referenceLocation, search.text)) {
+            // This wasn't the start of a token.  Check to see if it might be a
+            // match in a comment or string if that's what the caller is asking
+            // for.
+            if (!state.options.implementations && (state.options.findInStrings && isInString(sourceFile, position) || state.options.findInComments && isInNonReferenceComment(sourceFile, position))) {
+                // In the case where we're looking inside comments/strings, we don't have
+                // an actual definition.  So just use 'undefined' here.  Features like
+                // 'Rename' won't care (as they ignore the definitions), and features like
+                // 'FindReferences' will just filter out these results.
+                state.addStringOrCommentReference(sourceFile.fileName, createTextSpan(position, search.text.length));
+            }
+            return;
+        }
+        if (!hasMatchingMeaning(referenceLocation, state))
+            return;
+        const referenceSymbol = state.checker.getSymbolAtLocation(referenceLocation);
+        if (!referenceSymbol) {
+            return;
+        }
+        const parent = referenceLocation.parent;
+        if (isImportSpecifier(parent) && parent.propertyName === referenceLocation) {
+            // This is added through `singleReferences` in ImportsResult. If we happen to see it again, don't add it again.
+            return;
+        }
+        if (isExportSpecifier(parent)) {
+            Debug.assert(referenceLocation.kind === SyntaxKind.Identifier);
+            getReferencesAtExportSpecifier(referenceLocation, referenceSymbol, parent, search, state, addReferencesHere);
+            return;
+        }
+        const relatedSymbol = getRelatedSymbol(search, referenceSymbol, referenceLocation, state);
+        if (!relatedSymbol) {
+            getReferenceForShorthandProperty(referenceSymbol, search, state);
+            return;
+        }
+        // Na tag, a busca do nome de uma classe e do `constructor` acrescentava as referências do construtor e o `this`
+        // estático da classe (CK-02).
+        if (addReferencesHere)
+            addReference(referenceLocation, relatedSymbol, state);
+        getImportOrExportReferences(referenceLocation, referenceSymbol, search, state);
+    }
+    function getReferencesAtExportSpecifier(referenceLocation, referenceSymbol, exportSpecifier, search, state, addReferencesHere, alwaysGetReferences) {
+        Debug.assert(!alwaysGetReferences || !!state.options.providePrefixAndSuffixTextForRename, "If alwaysGetReferences is true, then prefix/suffix text must be enabled");
+        const { parent, propertyName, name } = exportSpecifier;
+        const exportDeclaration = parent.parent;
+        const localSymbol = getLocalSymbolForExportSpecifier(referenceLocation, referenceSymbol, exportSpecifier, state.checker);
+        if (!alwaysGetReferences && !search.includes(localSymbol)) {
+            return;
+        }
+        if (!propertyName) {
+            // Don't rename at `export { default } from "m";`. (but do continue to search for imports of the re-export)
+            if (!(state.options.use === 2 /* FindReferencesUse.Rename */ && (name.escapedText === InternalSymbolName.Default))) {
+                addRef();
+            }
+        }
+        else if (referenceLocation === propertyName) {
+            // For `export { foo as bar } from "baz"`, "`foo`" will be added from the singleReferences for import searches of the original export.
+            // For `export { foo as bar };`, where `foo` is a local, so add it now.
+            if (!exportDeclaration.moduleSpecifier) {
+                addRef();
+            }
+            if (addReferencesHere && state.options.use !== 2 /* FindReferencesUse.Rename */ && state.markSeenReExportRHS(name)) {
+                addReference(name, Debug.checkDefined(exportSpecifier.symbol), state);
+            }
+        }
+        else {
+            if (state.markSeenReExportRHS(referenceLocation)) {
+                addRef();
+            }
+        }
+        // For `export { foo as bar }`, rename `foo`, but not `bar`.
+        if (!isForRenameWithPrefixAndSuffixText(state.options) || alwaysGetReferences) {
+            const isDefaultExport = referenceLocation.originalKeywordKind === SyntaxKind.DefaultKeyword
+                || exportSpecifier.name.originalKeywordKind === SyntaxKind.DefaultKeyword;
+            const exportKind = isDefaultExport ? 1 /* ExportKind.Default */ : 0 /* ExportKind.Named */;
+            const exportSymbol = Debug.checkDefined(exportSpecifier.symbol);
+            const exportInfo = getExportInfo(exportSymbol, exportKind, state.checker);
+            if (exportInfo) {
+                searchForImportsOfExport(referenceLocation, exportSymbol, exportInfo, state);
+            }
+        }
+        // At `export { x } from "foo"`, also search for the imported symbol `"foo".x`.
+        if (search.comingFrom !== 1 /* ImportExport.Export */ && exportDeclaration.moduleSpecifier && !propertyName && !isForRenameWithPrefixAndSuffixText(state.options)) {
+            const imported = state.checker.getExportSpecifierLocalTargetSymbol(exportSpecifier);
+            if (imported)
+                searchForImportedSymbol(imported, state);
+        }
+        function addRef() {
+            if (addReferencesHere)
+                addReference(referenceLocation, localSymbol, state);
+        }
+    }
+    function getLocalSymbolForExportSpecifier(referenceLocation, referenceSymbol, exportSpecifier, checker) {
+        return isExportSpecifierAlias(referenceLocation, exportSpecifier) && checker.getExportSpecifierLocalTargetSymbol(exportSpecifier) || referenceSymbol;
+    }
+    function isExportSpecifierAlias(referenceLocation, exportSpecifier) {
+        const { parent, propertyName, name } = exportSpecifier;
+        Debug.assert(propertyName === referenceLocation || name === referenceLocation);
+        if (propertyName) {
+            // Given `export { foo as bar } [from "someModule"]`: It's an alias at `foo`, but at `bar` it's a new symbol.
+            return propertyName === referenceLocation;
+        }
+        else {
+            // `export { foo } from "foo"` is a re-export.
+            // `export { foo };` is not a re-export, it creates an alias for the local variable `foo`.
+            return !parent.parent.moduleSpecifier;
+        }
+    }
+    function getImportOrExportReferences(referenceLocation, referenceSymbol, search, state) {
+        const importOrExport = getImportOrExportSymbol(referenceLocation, referenceSymbol, state.checker, search.comingFrom === 1 /* ImportExport.Export */);
+        if (!importOrExport)
+            return;
+        const { symbol } = importOrExport;
+        if (importOrExport.kind === 0 /* ImportExport.Import */) {
+            if (!(isForRenameWithPrefixAndSuffixText(state.options))) {
+                searchForImportedSymbol(symbol, state);
+            }
+        }
+        else {
+            searchForImportsOfExport(referenceLocation, symbol, importOrExport.exportInfo, state);
+        }
+    }
+    function getReferenceForShorthandProperty({ flags, valueDeclaration }, search, state) {
+        const shorthandValueSymbol = state.checker.getShorthandAssignmentValueSymbol(valueDeclaration);
+        const name = valueDeclaration && getNameOfDeclaration(valueDeclaration);
+        /*
+        * Because in short-hand property assignment, an identifier which stored as name of the short-hand property assignment
+        * has two meanings: property name and property value. Therefore when we do findAllReference at the position where
+        * an identifier is declared, the language service should return the position of the variable declaration as well as
+        * the position in short-hand property assignment excluding property accessing. However, if we do findAllReference at the
+        * position of property accessing, the referenceEntry of such position will be handled in the first case.
+        */
+        if (!(flags & SymbolFlags.Transient) && name && search.includes(shorthandValueSymbol)) {
+            addReference(name, shorthandValueSymbol, state);
+        }
+    }
+    function addReference(referenceLocation, relatedSymbol, state) {
+        const { kind, symbol } = "kind" in relatedSymbol ? relatedSymbol : { kind: undefined, symbol: relatedSymbol }; // eslint-disable-line no-in-operator
+        const addRef = state.referenceAdder(symbol);
+        if (state.options.implementations) {
+            addImplementationReferences(referenceLocation, addRef, state);
+        }
+        else {
+            addRef(referenceLocation, kind);
+        }
+    }
+    function addImplementationReferences(refNode, addReference, state) {
+        // Check if we found a function/propertyAssignment/method with an implementation or initializer
+        if (isDeclarationName(refNode) && isImplementation(refNode.parent)) {
+            addReference(refNode);
+            return;
+        }
+        if (refNode.kind !== SyntaxKind.Identifier) {
+            return;
+        }
+        if (refNode.parent.kind === SyntaxKind.ShorthandPropertyAssignment) {
+            // Go ahead and dereference the shorthand assignment by going to its definition
+            getReferenceEntriesForShorthandPropertyAssignment(refNode, state.checker, addReference);
+        }
+        // Na tag, o nome no `extends` ou no `implements` de uma classe dava a classe como implementação (o
+        // `getContainingClassIfInHeritageClause`, CK-02).
+        // If we got a type reference, try and see if the reference applies to any expressions that can implement an interface
+        // Find the first node whose parent isn't a type node -- i.e., the highest type node.
+        const typeNode = findAncestor(refNode, a => !isQualifiedName(a.parent) && !isTypeNode(a.parent) && !isTypeElement(a.parent));
+        const typeHavingNode = typeNode.parent;
+        if (hasType(typeHavingNode) && typeHavingNode.type === typeNode && state.markSeenContainingTypeReference(typeHavingNode)) {
+            if (hasInitializer(typeHavingNode)) {
+                addIfImplementation(typeHavingNode.initializer);
+            }
+            else if (isFunctionLike(typeHavingNode) && typeHavingNode.body) {
+                const body = typeHavingNode.body;
+                if (body.kind === SyntaxKind.Block) {
+                    forEachReturnStatement(body, returnStatement => {
+                        if (returnStatement.expression)
+                            addIfImplementation(returnStatement.expression);
+                    });
+                }
+                else {
+                    addIfImplementation(body);
+                }
+            }
+            else if (isAssertionExpression(typeHavingNode)) {
+                addIfImplementation(typeHavingNode.expression);
+            }
+        }
+        function addIfImplementation(e) {
+            if (isImplementationExpression(e))
+                addReference(e);
+        }
+    }
+    /**
+     * Returns true if this is an expression that can be considered an implementation
+     */
+    function isImplementationExpression(node) {
+        // Na tag, também a function expression e a class expression (CK-02).
+        switch (node.kind) {
+            case SyntaxKind.ParenthesizedExpression:
+                return isImplementationExpression(node.expression);
+            case SyntaxKind.ArrowFunction:
+            case SyntaxKind.ObjectLiteralExpression:
+            case SyntaxKind.ArrayLiteralExpression:
+                return true;
+            default:
+                return false;
+        }
+    }
+    function getReferencesForStringLiteral(node, sourceFiles, cancellationToken) {
+        const references = flatMap(sourceFiles, sourceFile => {
+            cancellationToken.throwIfCancellationRequested();
+            return mapDefined(getPossibleSymbolReferenceNodes(sourceFile, node.text), ref => isStringLiteral(ref) && ref.text === node.text ? nodeEntry(ref, 2 /* EntryKind.StringLiteral */) : undefined);
+        });
+        return [{
+                definition: { type: 2 /* DefinitionKind.String */, node },
+                references
+            }];
+    }
+    // For certain symbol kinds, we need to include other symbols in the search set.
+    // This is not needed when searching for re-exports.
+    // Na tag, também o `implementations` e o `allowBaseTypes` do `forEachRelatedSymbol`, que só decidiam a busca nas
+    // bases, e o `baseSymbol` do callback, que trazia a propriedade da base (CK-02, CK-48).
+    function populateSearchSymbolSet(symbol, location, checker, isForRename, providePrefixAndSuffixText) {
+        const result = [];
+        forEachRelatedSymbol(symbol, location, checker, isForRename, !(isForRename && providePrefixAndSuffixText), (sym, root) => { result.push(root || sym); });
+        return result;
+    }
+    function forEachRelatedSymbol(symbol, location, checker, isForRenamePopulateSearchSymbolSet, onlyIncludeBindingElementAtReferenceLocation, cbSymbol) {
+        const containingObjectLiteralElement = getContainingObjectLiteralElement(location);
+        if (containingObjectLiteralElement) {
+            /* Because in short-hand property assignment, location has two meaning : property name and as value of the property
+            * When we do findAllReference at the position of the short-hand property assignment, we would want to have references to position of
+            * property name and variable declaration of the identifier.
+            * Like in below example, when querying for all references for an identifier 'name', of the property assignment, the language service
+            * should show both 'name' in 'obj' and 'name' in variable declaration
+            *      const name = "Foo";
+            *      const obj = { name };
+            * In order to do that, we will populate the search set with the value symbol of the identifier as a value of the property assignment
+            * so that when matching with potential reference symbol, both symbols from property declaration and variable declaration
+            * will be included correctly.
+            */
+            const shorthandValueSymbol = checker.getShorthandAssignmentValueSymbol(location.parent); // gets the local symbol
+            if (shorthandValueSymbol && isForRenamePopulateSearchSymbolSet) {
+                // When renaming 'x' in `const o = { x }`, just rename the local variable, not the property.
+                return cbSymbol(shorthandValueSymbol, /*rootSymbol*/ undefined, 3 /* EntryKind.SearchedLocalFoundProperty */);
+            }
+            // If the location is in a context sensitive location (i.e. in an object literal) try
+            // to get a contextual type for it, and add the property symbol from the contextual
+            // type to the search set
+            const contextualType = checker.getContextualType(containingObjectLiteralElement.parent);
+            const res = contextualType && firstDefined(getPropertySymbolsFromContextualType(containingObjectLiteralElement, checker, contextualType, /*unionSymbolOk*/ true), sym => fromRoot(sym, 4 /* EntryKind.SearchedPropertyFoundLocal */));
+            if (res)
+                return res;
+            // If the location is name of property symbol from object literal destructuring pattern
+            // Search the property symbol
+            //      for ( { property: p2 } of elems) { }
+            const propertySymbol = getPropertySymbolOfDestructuringAssignment(location, checker);
+            const res1 = propertySymbol && cbSymbol(propertySymbol, /*rootSymbol*/ undefined, 4 /* EntryKind.SearchedPropertyFoundLocal */);
+            if (res1)
+                return res1;
+            const res2 = shorthandValueSymbol && cbSymbol(shorthandValueSymbol, /*rootSymbol*/ undefined, 3 /* EntryKind.SearchedLocalFoundProperty */);
+            if (res2)
+                return res2;
+        }
+        // Na tag, também o global de um módulo UMD, pelo `export as namespace` (CK-03).
+        const res = fromRoot(symbol);
+        if (res)
+            return res;
+        // Na tag, a parameter property buscava também o outro símbolo dela: a propriedade, se era o parâmetro, e o
+        // parâmetro, se era a propriedade (CK-02).
+        const exportSpecifier = getDeclarationOfKind(symbol, SyntaxKind.ExportSpecifier);
+        if (!isForRenamePopulateSearchSymbolSet || exportSpecifier && !exportSpecifier.propertyName) {
+            const localSymbol = exportSpecifier && checker.getExportSpecifierLocalTargetSymbol(exportSpecifier);
+            if (localSymbol) {
+                const res = cbSymbol(localSymbol, /*rootSymbol*/ undefined, 1 /* EntryKind.Node */);
+                if (res)
+                    return res;
+            }
+        }
+        // symbolAtLocation for a binding element is the local symbol. See if the search symbol is the property.
+        // Don't do this when populating search set for a rename when prefix and suffix text will be provided -- just rename the local.
+        if (!isForRenamePopulateSearchSymbolSet) {
+            let bindingElementPropertySymbol;
+            if (onlyIncludeBindingElementAtReferenceLocation) {
+                bindingElementPropertySymbol = isObjectBindingElementWithoutPropertyName(location.parent) ? getPropertySymbolFromBindingElement(checker, location.parent) : undefined;
+            }
+            else {
+                bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol, checker);
+            }
+            return bindingElementPropertySymbol && fromRoot(bindingElementPropertySymbol, 4 /* EntryKind.SearchedPropertyFoundLocal */);
+        }
+        Debug.assert(isForRenamePopulateSearchSymbolSet);
+        // due to the above assert and the arguments at the uses of this function,
+        // (onlyIncludeBindingElementAtReferenceLocation <=> !providePrefixAndSuffixTextForRename) holds
+        const includeOriginalSymbolOfBindingElement = onlyIncludeBindingElementAtReferenceLocation;
+        if (includeOriginalSymbolOfBindingElement) {
+            const bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol, checker);
+            return bindingElementPropertySymbol && fromRoot(bindingElementPropertySymbol, 4 /* EntryKind.SearchedPropertyFoundLocal */);
+        }
+        function fromRoot(sym, kind) {
+            // If this is a union property:
+            //   - In populateSearchSymbolsSet we will add all the symbols from all its source symbols in all unioned types.
+            //   - In findRelatedSymbol, we will just use the union symbol if any source symbol is included in the search.
+            // If the symbol is an instantiation from a another symbol (e.g. widened symbol):
+            //   - In populateSearchSymbolsSet, add the root the list
+            //   - In findRelatedSymbol, return the source symbol if that is in the search. (Do not return the instantiation symbol.)
+            // Na tag, também a propriedade de mesmo nome nas classes e interfaces-base: a classe saiu (CK-02), e a interface
+            // que fica, a dos embutidos, não tem base (CK-48).
+            return firstDefined(checker.getRootSymbols(sym), rootSymbol => cbSymbol(sym, rootSymbol, kind));
+        }
+        function getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol, checker) {
+            const bindingElement = getDeclarationOfKind(symbol, SyntaxKind.BindingElement);
+            if (bindingElement && isObjectBindingElementWithoutPropertyName(bindingElement)) {
+                return getPropertySymbolFromBindingElement(checker, bindingElement);
+            }
+        }
+    }
+    function getRelatedSymbol(search, referenceSymbol, referenceLocation, state) {
+        const { checker } = state;
+        return forEachRelatedSymbol(referenceSymbol, referenceLocation, checker, /*isForRenamePopulateSearchSymbolSet*/ false, 
+        /*onlyIncludeBindingElementAtReferenceLocation*/ state.options.use !== 2 /* FindReferencesUse.Rename */ || !!state.options.providePrefixAndSuffixTextForRename, (sym, rootSymbol, kind) => search.includes(rootSymbol || sym)
+            // For a synthetic (e.g. union) property, use the union symbol.
+            ? { symbol: rootSymbol && !(getCheckFlags(sym) & CheckFlags.Synthetic) ? rootSymbol : sym, kind }
+            : undefined);
+    }
+    /**
+     * Given an initial searchMeaning, extracted from a location, widen the search scope based on the declarations
+     * of the corresponding symbol. e.g. if we are searching for "Foo" in value position, but "Foo" references a class
+     * then we need to widen the search to include type positions as well.
+     * On the contrary, if we are searching for "Bar" in type position and we trace bar to an interface, and an uninstantiated
+     * module, we want to keep the search limited to only types, as the two declarations (interface and uninstantiated module)
+     * do not intersect in any of the three spaces.
+     */
+    function getIntersectingMeaningFromDeclarations(node, symbol) {
+        let meaning = getMeaningFromLocation(node);
+        const { declarations } = symbol;
+        if (declarations) {
+            let lastIterationMeaning;
+            do {
+                // The result is order-sensitive, for instance if initialMeaning === Namespace, and declarations = [class, instantiated module]
+                // we need to consider both as they initialMeaning intersects with the module in the namespace space, and the module
+                // intersects with the class in the value space.
+                // To achieve that we will keep iterating until the result stabilizes.
+                // Remember the last meaning
+                lastIterationMeaning = meaning;
+                for (const declaration of declarations) {
+                    const declarationMeaning = getMeaningFromDeclaration(declaration);
+                    if (declarationMeaning & meaning) {
+                        meaning |= declarationMeaning;
+                    }
+                }
+            } while (meaning !== lastIterationMeaning);
+        }
+        return meaning;
+    }
+    Core.getIntersectingMeaningFromDeclarations = getIntersectingMeaningFromDeclarations;
+    /** Na tag, também a classe e o enum, e, no contexto ambiente, a interface não era implementação (CK-02). */
+    function isImplementation(node) {
+        return !!(node.flags & NodeFlags.Ambient) ? !isTypeAliasDeclaration(node) :
+            (isVariableLike(node) ? hasInitializer(node) :
+                isFunctionLikeDeclaration(node) ? !!node.body :
+                    isModuleDeclaration(node));
+    }
+    function getReferenceEntriesForShorthandPropertyAssignment(node, checker, addReference) {
+        const refSymbol = checker.getSymbolAtLocation(node);
+        const shorthandSymbol = checker.getShorthandAssignmentValueSymbol(refSymbol.valueDeclaration);
+        if (shorthandSymbol) {
+            for (const declaration of shorthandSymbol.getDeclarations()) {
+                if (getMeaningFromDeclaration(declaration) & 1 /* SemanticMeaning.Value */) {
+                    addReference(declaration);
+                }
+            }
+        }
+    }
+    Core.getReferenceEntriesForShorthandPropertyAssignment = getReferenceEntriesForShorthandPropertyAssignment;
+    function isForRenameWithPrefixAndSuffixText(options) {
+        return options.use === 2 /* FindReferencesUse.Rename */ && options.providePrefixAndSuffixTextForRename;
+    }
+})(Core || (Core = {}));