@tslite/parser 1.10.0 → 1.12.0

package/dist/utilities.js

@@ -0,0 +1,2632 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/utilities.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, Diagnostics, Map, arrayToMap, assertType, binarySearch, compareStringsCaseSensitive, compareValues, computeLineOfPosition, contains, createMap, createMapFromTemplate, createScanner, createTextSpan, createTextSpanFromBounds, equateValues, escapeLeadingUnderscores, every, fileExtensionIs, find, firstOrUndefined, forEach, forEachChild, getBaseFileName, getCombinedModifierFlags, getCombinedNodeFlags, getLeadingCommentRanges, getLineAndCharacterOfPosition, getLineStarts, getLinesBetweenPositions, getNameOfDeclaration, idText, isBigIntLiteral, isBinaryExpression, isAnyDirectorySeparator, isBindingPattern, isCallExpression, isComputedPropertyName, isDeclaration, isElementAccessExpression, isExportAssignment, isExportDeclaration, isExternalModule, isFunctionLike, isFunctionLikeDeclaration, isIdentifier, isImportTypeNode, isJsxText, isLeftHandSideExpression, isLineBreak, isLiteralTypeNode, isMetaProperty, isModuleDeclaration, isNumericLiteral, isObjectLiteralExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isQualifiedName, isSourceFile, isString, isStringLiteral, isStringLiteralLike, isTypeLiteralNode, isTypeReferenceNode, isVariableDeclaration, isVariableStatement, isWhiteSpaceLike, lastOrUndefined, length, returnTrue, skipOuterExpressions, skipTrivia, some, startsWith, stringContains, stringToToken, tryCast, tryRemovePrefix, unescapeLeadingUnderscores, } from "./_namespaces/ts.js";
+export const defaultMaximumTruncationLength = 160;
+export const noTruncationMaximumTruncationLength = 1_000_000;
+export function getDeclarationOfKind(symbol, kind) {
+    const declarations = symbol.declarations;
+    if (declarations) {
+        for (const declaration of declarations) {
+            if (declaration.kind === kind) {
+                return declaration;
+            }
+        }
+    }
+    return undefined;
+}
+/** Create a new escaped identifier map. */
+export function createUnderscoreEscapedMap() {
+    return new Map();
+}
+export function hasEntries(map) {
+    return !!map && !!map.size;
+}
+export function createSymbolTable(symbols) {
+    const result = createMap();
+    if (symbols) {
+        for (const symbol of symbols) {
+            result.set(symbol.escapedName, symbol);
+        }
+    }
+    return result;
+}
+export function findAncestor(node, callback) {
+    while (node) {
+        const result = callback(node);
+        if (result === "quit") {
+            return undefined;
+        }
+        else if (result) {
+            return node;
+        }
+        node = node.parent;
+    }
+    return undefined;
+}
+export function forEachEntry(map, callback) {
+    const iterator = map.entries();
+    for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
+        const [key, value] = iterResult.value;
+        const result = callback(value, key);
+        if (result) {
+            return result;
+        }
+    }
+    return undefined;
+}
+export function forEachKey(map, callback) {
+    const iterator = map.keys();
+    for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
+        const result = callback(iterResult.value);
+        if (result) {
+            return result;
+        }
+    }
+    return undefined;
+}
+export function copyEntries(source, target) {
+    source.forEach((value, key) => {
+        target.set(key, value);
+    });
+}
+export function arrayToSet(array, makeKey) {
+    return arrayToMap(array, makeKey || (s => s), returnTrue);
+}
+export function cloneMap(map) {
+    const clone = createMap();
+    copyEntries(map, clone);
+    return clone;
+}
+export function getFullWidth(node) {
+    return node.end - node.pos;
+}
+export function getResolvedModule(sourceFile, moduleNameText) {
+    return sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(moduleNameText);
+}
+export function setResolvedModule(sourceFile, moduleNameText, resolvedModule) {
+    if (!sourceFile.resolvedModules) {
+        sourceFile.resolvedModules = createMap();
+    }
+    sourceFile.resolvedModules.set(moduleNameText, resolvedModule);
+}
+// Returns true if this node contains a parse error anywhere underneath it.
+export function containsParseError(node) {
+    aggregateChildData(node);
+    return (node.flags & 262144 /* NodeFlags.ThisNodeOrAnySubNodesHasError */) !== 0;
+}
+function aggregateChildData(node) {
+    if (!(node.flags & 524288 /* NodeFlags.HasAggregatedChildData */)) {
+        // A node is considered to contain a parse error if:
+        //  a) the parser explicitly marked that it had an error
+        //  b) any of it's children reported that it had an error.
+        const thisNodeOrAnySubNodesHasError = ((node.flags & 65536 /* NodeFlags.ThisNodeHasError */) !== 0) ||
+            forEachChild(node, containsParseError);
+        // If so, mark ourselves accordingly.
+        if (thisNodeOrAnySubNodesHasError) {
+            node.flags |= 262144 /* NodeFlags.ThisNodeOrAnySubNodesHasError */;
+        }
+        // Also mark that we've propagated the child information to this node.  This way we can
+        // always consult the bit directly on this node without needing to check its children
+        // again.
+        node.flags |= 524288 /* NodeFlags.HasAggregatedChildData */;
+    }
+}
+let nextNodeId = 1;
+/** O id do nó, dado na primeira vez que alguém pede: indexa as tabelas laterais do binder e do checker. */
+export function getNodeId(node) {
+    if (!node.id) {
+        node.id = nextNodeId;
+        nextNodeId++;
+    }
+    return node.id;
+}
+export function getSourceFileOfNode(node) {
+    while (node && node.kind !== 290 /* SyntaxKind.SourceFile */) {
+        node = node.parent;
+    }
+    return node;
+}
+export function getStartPositionOfLine(line, sourceFile) {
+    Debug.assert(line >= 0);
+    return getLineStarts(sourceFile)[line];
+}
+export function getEndLinePosition(line, sourceFile) {
+    Debug.assert(line >= 0);
+    const lineStarts = getLineStarts(sourceFile);
+    const lineIndex = line;
+    const sourceText = sourceFile.text;
+    if (lineIndex + 1 === lineStarts.length) {
+        // last line - return EOF
+        return sourceText.length - 1;
+    }
+    else {
+        // current line start
+        const start = lineStarts[lineIndex];
+        // take the start position of the next line - 1 = it should be some line break
+        let pos = lineStarts[lineIndex + 1] - 1;
+        Debug.assert(isLineBreak(sourceText.charCodeAt(pos)));
+        // walk backwards skipping line breaks, stop the the beginning of current line.
+        // i.e:
+        // <some text>
+        // $ <- end of line for this position should match the start position
+        while (start <= pos && isLineBreak(sourceText.charCodeAt(pos))) {
+            pos--;
+        }
+        return pos;
+    }
+}
+// Returns true if this node is missing from the actual source code. A 'missing' node is different
+// from 'undefined/defined'. When a node is undefined (which can happen for optional nodes
+// in the tree), it is definitely missing. However, a node may be defined, but still be
+// missing.  This happens whenever the parser knows it needs to parse something, but can't
+// get anything in the source code that it expects at that location. For example:
+//
+//          let a: ;
+//
+// Here, the Type in the Type-Annotation is not-optional (as there is a colon in the source
+// code). So the parser will attempt to parse out a type, and will create an actual node.
+// However, this node will be 'missing' in the sense that no actual source-code/tokens are
+// contained within it.
+export function nodeIsMissing(node) {
+    if (node === undefined) {
+        return true;
+    }
+    return node.pos === node.end && node.pos >= 0 && node.kind !== 1 /* SyntaxKind.EndOfFileToken */;
+}
+export function nodeIsPresent(node) {
+    return !nodeIsMissing(node);
+}
+/**
+ * Determine if the given comment is a triple-slash
+ *
+ * @return true if the comment is a triple-slash comment else false
+ */
+export function isRecognizedTripleSlashComment(text, commentPos, commentEnd) {
+    // Verify this is /// comment, but do the regexp match only when we first can find /// in the comment text
+    // so that we don't end up computing comment string and doing match for all // comments
+    if (text.charCodeAt(commentPos + 1) === 47 /* CharacterCodes.slash */ &&
+        commentPos + 2 < commentEnd &&
+        text.charCodeAt(commentPos + 2) === 47 /* CharacterCodes.slash */) {
+        const textSubStr = text.substring(commentPos, commentEnd);
+        // Na tag, também a referência por texto (`path`) e o `amd-dependency` (CK-03), e a dos pacotes de tipos
+        // (`types`, CK-46); fica a diretiva da lib.
+        return textSubStr.match(defaultLibReferenceRegEx) ?
+            true : false;
+    }
+    return false;
+}
+export function isPinnedComment(text, start) {
+    return text.charCodeAt(start + 1) === 42 /* CharacterCodes.asterisk */ &&
+        text.charCodeAt(start + 2) === 33 /* CharacterCodes.exclamation */;
+}
+export function getTokenPosOfNode(node, sourceFile) {
+    // With nodes that have no width (i.e. 'Missing' nodes), we actually *don't*
+    // want to skip trivia because this will launch us forward to the next token.
+    if (nodeIsMissing(node)) {
+        return node.pos;
+    }
+    // Uma syntax list começa no primeiro token do primeiro filho.
+    if (node.kind === 324 /* SyntaxKind.SyntaxList */ && node._children.length > 0) {
+        return getTokenPosOfNode(node._children[0], sourceFile);
+    }
+    return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos);
+}
+export function getSourceTextOfNodeFromSourceFile(sourceFile, node, includeTrivia = false) {
+    return getTextOfNodeFromSourceText(sourceFile.text, node, includeTrivia);
+}
+export function getTextOfNodeFromSourceText(sourceText, node, includeTrivia = false) {
+    if (nodeIsMissing(node)) {
+        return "";
+    }
+    return sourceText.substring(includeTrivia ? node.pos : skipTrivia(sourceText, node.pos), node.end);
+}
+export function getTextOfNode(node, includeTrivia = false) {
+    return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node, includeTrivia);
+}
+function getPos(range) {
+    return range.pos;
+}
+/**
+ * Note: it is expected that the `nodeArray` and the `node` are within the same file.
+ * For example, searching for a `SourceFile` in a `SourceFile[]` wouldn't work.
+ */
+export function indexOfNode(nodeArray, node) {
+    return binarySearch(nodeArray, node, getPos, compareValues);
+}
+/**
+ * Gets flags that control emit behavior of a node.
+ */
+export function getEmitFlags(node) {
+    const emitNode = node.emitNode;
+    return emitNode && emitNode.flags || 0;
+}
+export function getLiteralText(node, sourceFile, neverAsciiEscape, jsxAttributeEscape) {
+    // If we don't need to downlevel and we can reach the original source text using
+    // the node's parent reference, then simply get the text as it was originally written.
+    if (!nodeIsSynthesized(node) && node.parent && !((isNumericLiteral(node) && node.numericLiteralFlags & 512 /* TokenFlags.ContainsSeparator */) ||
+        isBigIntLiteral(node))) {
+        return getSourceTextOfNodeFromSourceFile(sourceFile, node);
+    }
+    // If we can't reach the original source text, use the canonical form if it's a number,
+    // or a (possibly escaped) quoted form of the original text if it's string-like.
+    switch (node.kind) {
+        case 10 /* SyntaxKind.StringLiteral */: {
+            const escapeText = jsxAttributeEscape ? escapeJsxAttributeString :
+                neverAsciiEscape || (getEmitFlags(node) & 16777216 /* EmitFlags.NoAsciiEscaping */) ? escapeString :
+                    escapeNonAsciiString;
+            if (node.singleQuote) {
+                return "'" + escapeText(node.text, 39 /* CharacterCodes.singleQuote */) + "'";
+            }
+            else {
+                return '"' + escapeText(node.text, 34 /* CharacterCodes.doubleQuote */) + '"';
+            }
+        }
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 15 /* SyntaxKind.TemplateHead */:
+        case 16 /* SyntaxKind.TemplateMiddle */:
+        case 17 /* SyntaxKind.TemplateTail */: {
+            // If a NoSubstitutionTemplateLiteral appears to have a substitution in it, the original text
+            // had to include a backslash: `not \${a} substitution`.
+            const escapeText = neverAsciiEscape || (getEmitFlags(node) & 16777216 /* EmitFlags.NoAsciiEscaping */) ? escapeString :
+                escapeNonAsciiString;
+            const rawText = node.rawText ?? escapeTemplateSubstitution(escapeText(node.text, 96 /* CharacterCodes.backtick */));
+            switch (node.kind) {
+                case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+                    return "`" + rawText + "`";
+                case 15 /* SyntaxKind.TemplateHead */:
+                    return "`" + rawText + "${";
+                case 16 /* SyntaxKind.TemplateMiddle */:
+                    return "}" + rawText + "${";
+                case 17 /* SyntaxKind.TemplateTail */:
+                    return "}" + rawText + "`";
+            }
+            break;
+        }
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+            return node.text;
+    }
+    return Debug.fail(`Literal kind '${node.kind}' not accounted for.`);
+}
+// Make an identifier from an external module name by extracting the string after the last "/" and replacing
+// all non-alphanumeric characters with underscores
+export function makeIdentifierFromModuleName(moduleName) {
+    return getBaseFileName(moduleName).replace(/^(\d)/, "_$1").replace(/\W/g, "_");
+}
+export function isBlockOrCatchScoped(declaration) {
+    return (getCombinedNodeFlags(declaration) & 3 /* NodeFlags.BlockScoped */) !== 0 ||
+        isCatchClauseVariableDeclarationOrBindingElement(declaration);
+}
+export function isCatchClauseVariableDeclarationOrBindingElement(declaration) {
+    const node = getRootDeclaration(declaration);
+    return node.kind === 242 /* SyntaxKind.VariableDeclaration */ && node.parent.kind === 280 /* SyntaxKind.CatchClause */;
+}
+/** O módulo ambiente é só o `declare global`: o de nome em string (`declare module "x"`) saiu (CK-02, princípio 4). */
+export function isAmbientModule(node) {
+    return isModuleDeclaration(node) && isGlobalScopeAugmentation(node);
+}
+/**
+ * An effective module (namespace) declaration is either
+ * 1. An actual declaration: namespace X { ... }
+ * 2. A Javascript declaration, which is:
+ *    An identifier in a nested property access expression: Y in `X.Y.Z = { ... }`
+ */
+export function isEffectiveModuleDeclaration(node) {
+    return isModuleDeclaration(node) || isIdentifier(node);
+}
+export function isGlobalScopeAugmentation(module) {
+    return !!(module.flags & 1024 /* NodeFlags.GlobalAugmentation */);
+}
+export function isExternalModuleAugmentation(node) {
+    return isAmbientModule(node) && isModuleAugmentationExternal(node);
+}
+export function isModuleAugmentationExternal(node) {
+    // external module augmentation is a ambient module declaration that is either:
+    // - defined in the top level scope and source file is an external module
+    // - defined inside ambient module declaration located in the top level scope and source file not an external module
+    switch (node.parent.kind) {
+        case 290 /* SyntaxKind.SourceFile */:
+            return isExternalModule(node.parent);
+        case 250 /* SyntaxKind.ModuleBlock */:
+            return isAmbientModule(node.parent.parent) && isSourceFile(node.parent.parent.parent) && !isExternalModule(node.parent.parent.parent);
+    }
+    return false;
+}
+export function getNonAugmentationDeclaration(symbol) {
+    return find(symbol.declarations, d => !isExternalModuleAugmentation(d) && !(isModuleDeclaration(d) && isGlobalScopeAugmentation(d)));
+}
+export function isBlockScope(node, parentNode) {
+    switch (node.kind) {
+        case 290 /* SyntaxKind.SourceFile */:
+        case 251 /* SyntaxKind.CaseBlock */:
+        case 280 /* SyntaxKind.CatchClause */:
+        case 249 /* SyntaxKind.ModuleDeclaration */:
+        case 230 /* SyntaxKind.ForStatement */:
+        case 231 /* SyntaxKind.ForInStatement */:
+        case 232 /* SyntaxKind.ForOfStatement */:
+        case 202 /* SyntaxKind.ArrowFunction */:
+            return true;
+        case 223 /* SyntaxKind.Block */:
+            // function block is not considered block-scope container
+            // see comment in binder.ts: bind(...), case for SyntaxKind.Block
+            return !isFunctionLike(parentNode);
+    }
+    return false;
+}
+/** Na tag, também o callback, o typedef e a assinatura do JSDoc, que têm parâmetros de tipo sem filhos (CK-03). */
+export function isDeclarationWithTypeParameters(node) {
+    return isDeclarationWithTypeParameterChildren(node);
+}
+export function isDeclarationWithTypeParameterChildren(node) {
+    Debug.type(node);
+    switch (node.kind) {
+        case 165 /* SyntaxKind.CallSignature */:
+        case 160 /* SyntaxKind.MethodSignature */:
+        case 167 /* SyntaxKind.IndexSignature */:
+        case 170 /* SyntaxKind.FunctionType */:
+        case 247 /* SyntaxKind.TypeAliasDeclaration */:
+        case 202 /* SyntaxKind.ArrowFunction */:
+            return true;
+        default:
+            assertType(node);
+            return false;
+    }
+}
+export function isAnyImportSyntax(node) {
+    switch (node.kind) {
+        case 254 /* SyntaxKind.ImportDeclaration */:
+            return true;
+        default:
+            return false;
+    }
+}
+export function isLateVisibilityPaintedStatement(node) {
+    switch (node.kind) {
+        case 254 /* SyntaxKind.ImportDeclaration */:
+        case 225 /* SyntaxKind.VariableStatement */:
+        case 249 /* SyntaxKind.ModuleDeclaration */:
+        case 247 /* SyntaxKind.TypeAliasDeclaration */:
+            return true;
+        default:
+            return false;
+    }
+}
+export function isAnyImportOrReExport(node) {
+    return isAnyImportSyntax(node) || isExportDeclaration(node);
+}
+// Gets the nearest enclosing block scope container that has the provided node
+// as a descendant, that is not the provided node.
+export function getEnclosingBlockScopeContainer(node) {
+    return findAncestor(node.parent, current => isBlockScope(current, current.parent));
+}
+// Return display name of an identifier
+// Computed property names will just be emitted as "[<expr>]", where <expr> is the source
+// text of the expression in the computed property.
+export function declarationNameToString(name) {
+    return !name || getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name);
+}
+export function isComputedNonLiteralName(name) {
+    return name.kind === 154 /* SyntaxKind.ComputedPropertyName */ && !isStringOrNumericLiteralLike(name.expression);
+}
+export function createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3) {
+    const sourceFile = getSourceFileOfNode(node);
+    return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3);
+}
+export function createDiagnosticForNodeArray(sourceFile, nodes, message, arg0, arg1, arg2, arg3) {
+    const start = skipTrivia(sourceFile.text, nodes.pos);
+    return createFileDiagnostic(sourceFile, start, nodes.end - start, message, arg0, arg1, arg2, arg3);
+}
+export function createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3) {
+    const span = getErrorSpanForNode(sourceFile, node);
+    return createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2, arg3);
+}
+export function createDiagnosticForNodeFromMessageChain(node, messageChain, relatedInformation) {
+    const sourceFile = getSourceFileOfNode(node);
+    const span = getErrorSpanForNode(sourceFile, node);
+    return {
+        file: sourceFile,
+        start: span.start,
+        length: span.length,
+        code: messageChain.code,
+        category: messageChain.category,
+        messageText: messageChain.next ? messageChain : messageChain.messageText,
+        relatedInformation
+    };
+}
+export function createDiagnosticForRange(sourceFile, range, message) {
+    return {
+        file: sourceFile,
+        start: range.pos,
+        length: range.end - range.pos,
+        code: message.code,
+        category: message.category,
+        messageText: message.message,
+    };
+}
+export function getSpanOfTokenAtPosition(sourceFile, pos) {
+    const scanner = createScanner(sourceFile.languageVersion, /*skipTrivia*/ true, sourceFile.languageVariant, sourceFile.text, /*onError:*/ undefined, pos);
+    scanner.scan();
+    const start = scanner.getTokenPos();
+    return createTextSpanFromBounds(start, scanner.getTextPos());
+}
+function getErrorSpanForArrowFunction(sourceFile, node) {
+    const pos = skipTrivia(sourceFile.text, node.pos);
+    if (node.body && node.body.kind === 223 /* SyntaxKind.Block */) {
+        const { line: startLine } = getLineAndCharacterOfPosition(sourceFile, node.body.pos);
+        const { line: endLine } = getLineAndCharacterOfPosition(sourceFile, node.body.end);
+        if (startLine < endLine) {
+            // The arrow function spans multiple lines,
+            // make the error span be the first line, inclusive.
+            return createTextSpan(pos, getEndLinePosition(startLine, sourceFile) - pos + 1);
+        }
+    }
+    return createTextSpanFromBounds(pos, node.end);
+}
+export function getErrorSpanForNode(sourceFile, node) {
+    let errorNode = node;
+    switch (node.kind) {
+        case 290 /* SyntaxKind.SourceFile */:
+            const pos = skipTrivia(sourceFile.text, 0, /*stopAfterLineBreak*/ false);
+            if (pos === sourceFile.text.length) {
+                // file is empty - return span for the beginning of the file
+                return createTextSpan(0, 0);
+            }
+            return getSpanOfTokenAtPosition(sourceFile, pos);
+        // This list is a work in progress. Add missing node kinds to improve their error
+        // spans.
+        case 242 /* SyntaxKind.VariableDeclaration */:
+        case 191 /* SyntaxKind.BindingElement */:
+        case 249 /* SyntaxKind.ModuleDeclaration */:
+        case 247 /* SyntaxKind.TypeAliasDeclaration */:
+        case 158 /* SyntaxKind.PropertySignature */:
+            errorNode = node.name;
+            break;
+        case 202 /* SyntaxKind.ArrowFunction */:
+            return getErrorSpanForArrowFunction(sourceFile, node);
+        case 277 /* SyntaxKind.CaseClause */:
+        case 278 /* SyntaxKind.DefaultClause */:
+            const start = skipTrivia(sourceFile.text, node.pos);
+            const end = node.statements.length > 0 ? node.statements[0].pos : node.end;
+            return createTextSpanFromBounds(start, end);
+    }
+    if (errorNode === undefined) {
+        // If we don't have a better node, then just set the error on the first token of
+        // construct.
+        return getSpanOfTokenAtPosition(sourceFile, node.pos);
+    }
+    const isMissing = nodeIsMissing(errorNode);
+    const pos = isMissing || isJsxText(node)
+        ? errorNode.pos
+        : skipTrivia(sourceFile.text, errorNode.pos);
+    // These asserts should all be satisfied for a properly constructed `errorNode`.
+    if (isMissing) {
+        Debug.assert(pos === errorNode.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");
+        Debug.assert(pos === errorNode.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");
+    }
+    else {
+        Debug.assert(pos >= errorNode.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");
+        Debug.assert(pos <= errorNode.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");
+    }
+    return createTextSpanFromBounds(pos, errorNode.end);
+}
+export function isExternalOrCommonJsModule(file) {
+    return (file.externalModuleIndicator || file.commonJsModuleIndicator) !== undefined;
+}
+export function isJsonSourceFile(file) {
+    return file.scriptKind === 6 /* ScriptKind.JSON */;
+}
+export function isDeclarationReadonly(declaration) {
+    return !!(getCombinedModifierFlags(declaration) & 64 /* ModifierFlags.Readonly */);
+}
+export function isVarConst(node) {
+    return !!(getCombinedNodeFlags(node) & 2 /* NodeFlags.Const */);
+}
+export function isLet(node) {
+    return !!(getCombinedNodeFlags(node) & 1 /* NodeFlags.Let */);
+}
+export function isImportCall(n) {
+    return n.kind === 196 /* SyntaxKind.CallExpression */ && n.expression.kind === 96 /* SyntaxKind.ImportKeyword */;
+}
+export function isImportMeta(n) {
+    return isMetaProperty(n)
+        && n.keywordToken === 96 /* SyntaxKind.ImportKeyword */
+        && n.name.escapedText === "meta";
+}
+export function isLiteralImportTypeNode(n) {
+    return isImportTypeNode(n) && isLiteralTypeNode(n.argument) && isStringLiteral(n.argument.literal);
+}
+export function isPrologueDirective(node) {
+    return node.kind === 226 /* SyntaxKind.ExpressionStatement */
+        && node.expression.kind === 10 /* SyntaxKind.StringLiteral */;
+}
+export function isCustomPrologue(node) {
+    return !!(getEmitFlags(node) & 1048576 /* EmitFlags.CustomPrologue */);
+}
+function isHoistedVariable(node) {
+    return isIdentifier(node.name)
+        && !node.initializer;
+}
+export function isHoistedVariableStatement(node) {
+    return isCustomPrologue(node)
+        && isVariableStatement(node)
+        && every(node.declarationList.declarations, isHoistedVariable);
+}
+export function getLeadingCommentRangesOfNode(node, sourceFileOfNode) {
+    return node.kind !== 11 /* SyntaxKind.JsxText */ ? getLeadingCommentRanges(sourceFileOfNode.text, node.pos) : undefined;
+}
+const defaultLibReferenceRegEx = /^(\/\/\/\s*<reference\s+no-default-lib\s*=\s*)('|")(.+?)\2\s*\/>/;
+export function isPartOfTypeNode(node) {
+    if (168 /* SyntaxKind.FirstTypeNode */ <= node.kind && node.kind <= 188 /* SyntaxKind.LastTypeNode */) {
+        return true;
+    }
+    switch (node.kind) {
+        case 125 /* SyntaxKind.AnyKeyword */:
+        case 148 /* SyntaxKind.UnknownKeyword */:
+        case 140 /* SyntaxKind.NumberKeyword */:
+        case 151 /* SyntaxKind.BigIntKeyword */:
+        case 143 /* SyntaxKind.StringKeyword */:
+        case 128 /* SyntaxKind.BooleanKeyword */:
+        case 141 /* SyntaxKind.ObjectKeyword */:
+        case 146 /* SyntaxKind.UndefinedKeyword */:
+        case 137 /* SyntaxKind.NeverKeyword */:
+        case 110 /* SyntaxKind.VoidKeyword */:
+            return true;
+        case 155 /* SyntaxKind.TypeParameter */:
+            return node.parent.kind === 186 /* SyntaxKind.MappedType */ || node.parent.kind === 181 /* SyntaxKind.InferType */;
+        // Identifiers and qualified names may be type nodes, depending on their context. Climb
+        // above them to find the lowest container
+        case 75 /* SyntaxKind.Identifier */:
+            // If the identifier is the RHS of a qualified name, then it's a type iff its parent is.
+            if (node.parent.kind === 153 /* SyntaxKind.QualifiedName */ && node.parent.right === node) {
+                node = node.parent;
+            }
+            else if (node.parent.kind === 194 /* SyntaxKind.PropertyAccessExpression */ && node.parent.name === node) {
+                node = node.parent;
+            }
+            // At this point, node is either a qualified name or an identifier
+            Debug.assert(node.kind === 75 /* SyntaxKind.Identifier */ || node.kind === 153 /* SyntaxKind.QualifiedName */ || node.kind === 194 /* SyntaxKind.PropertyAccessExpression */, "'node' was expected to be a qualified name, identifier or property access in 'isPartOfTypeNode'.");
+        // falls through
+        case 153 /* SyntaxKind.QualifiedName */:
+        case 194 /* SyntaxKind.PropertyAccessExpression */: {
+            const { parent } = node;
+            if (parent.kind === 172 /* SyntaxKind.TypeQuery */) {
+                return false;
+            }
+            if (parent.kind === 188 /* SyntaxKind.ImportType */) {
+                return !parent.isTypeOf;
+            }
+            // Do not recursively call isPartOfTypeNode on the parent. In the example:
+            //
+            //     let a: A.B.C;
+            //
+            // Calling isPartOfTypeNode would consider the qualified name A.B a type node.
+            // Only C and A.B.C are type nodes.
+            if (168 /* SyntaxKind.FirstTypeNode */ <= parent.kind && parent.kind <= 188 /* SyntaxKind.LastTypeNode */) {
+                return true;
+            }
+            switch (parent.kind) {
+                case 155 /* SyntaxKind.TypeParameter */:
+                    return node === parent.constraint;
+                case 158 /* SyntaxKind.PropertySignature */:
+                case 156 /* SyntaxKind.Parameter */:
+                case 242 /* SyntaxKind.VariableDeclaration */:
+                    return node === parent.type;
+                case 202 /* SyntaxKind.ArrowFunction */:
+                    return node === parent.type;
+                case 165 /* SyntaxKind.CallSignature */:
+                case 167 /* SyntaxKind.IndexSignature */:
+                    return node === parent.type;
+                case 196 /* SyntaxKind.CallExpression */:
+                    return contains(parent.typeArguments, node);
+            }
+        }
+    }
+    return false;
+}
+// Warning: This has the same semantics as the forEach family of functions,
+//          in that traversal terminates in the event that 'visitor' supplies a truthy value.
+export function forEachReturnStatement(body, visitor) {
+    return traverse(body);
+    function traverse(node) {
+        switch (node.kind) {
+            case 235 /* SyntaxKind.ReturnStatement */:
+                return visitor(node);
+            case 251 /* SyntaxKind.CaseBlock */:
+            case 223 /* SyntaxKind.Block */:
+            case 227 /* SyntaxKind.IfStatement */:
+            case 228 /* SyntaxKind.DoStatement */:
+            case 229 /* SyntaxKind.WhileStatement */:
+            case 230 /* SyntaxKind.ForStatement */:
+            case 231 /* SyntaxKind.ForInStatement */:
+            case 232 /* SyntaxKind.ForOfStatement */:
+            case 237 /* SyntaxKind.SwitchStatement */:
+            case 277 /* SyntaxKind.CaseClause */:
+            case 278 /* SyntaxKind.DefaultClause */:
+            case 240 /* SyntaxKind.TryStatement */:
+            case 280 /* SyntaxKind.CatchClause */:
+                return forEachChild(node, traverse);
+        }
+    }
+}
+export function getMembersOfDeclaration(node) {
+    switch (node.kind) {
+        case 173 /* SyntaxKind.TypeLiteral */:
+            return node.members;
+        case 193 /* SyntaxKind.ObjectLiteralExpression */:
+            return node.properties;
+    }
+}
+export function isVariableLike(node) {
+    if (node) {
+        switch (node.kind) {
+            case 191 /* SyntaxKind.BindingElement */:
+            case 156 /* SyntaxKind.Parameter */:
+            case 281 /* SyntaxKind.PropertyAssignment */:
+            case 158 /* SyntaxKind.PropertySignature */:
+            case 282 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 242 /* SyntaxKind.VariableDeclaration */:
+                return true;
+        }
+    }
+    return false;
+}
+export function isFunctionBlock(node) {
+    return node && node.kind === 223 /* SyntaxKind.Block */ && isFunctionLike(node.parent);
+}
+export function getContainingFunction(node) {
+    return findAncestor(node.parent, isFunctionLike);
+}
+export function getContainingFunctionDeclaration(node) {
+    return findAncestor(node.parent, isFunctionLikeDeclaration);
+}
+export function getThisContainer(node, includeArrowFunctions) {
+    Debug.assert(node.kind !== 290 /* SyntaxKind.SourceFile */);
+    while (true) {
+        node = node.parent;
+        if (!node) {
+            return Debug.fail(); // If we never pass in a SourceFile, this should be unreachable, since we'll stop when we reach that.
+        }
+        switch (node.kind) {
+            case 154 /* SyntaxKind.ComputedPropertyName */:
+                // O pai de um nome computado é a propriedade que ele nomeia, e não é o contêiner.
+                node = node.parent;
+                break;
+            case 202 /* SyntaxKind.ArrowFunction */:
+                if (!includeArrowFunctions) {
+                    continue;
+                }
+            // falls through
+            case 249 /* SyntaxKind.ModuleDeclaration */:
+            case 158 /* SyntaxKind.PropertySignature */:
+            case 165 /* SyntaxKind.CallSignature */:
+            case 167 /* SyntaxKind.IndexSignature */:
+            case 290 /* SyntaxKind.SourceFile */:
+                return node;
+        }
+    }
+}
+export function getImmediatelyInvokedFunctionExpression(func) {
+    if (func.kind === 202 /* SyntaxKind.ArrowFunction */) {
+        let prev = func;
+        let parent = func.parent;
+        while (parent.kind === 200 /* SyntaxKind.ParenthesizedExpression */) {
+            prev = parent;
+            parent = parent.parent;
+        }
+        if (parent.kind === 196 /* SyntaxKind.CallExpression */ && parent.expression === prev) {
+            return parent;
+        }
+    }
+}
+/** O nome de uma referência de tipo. Na tag, também o de um `extends` ou de um `implements` (CK-02). */
+export function getEntityNameFromTypeNode(node) {
+    switch (node.kind) {
+        case 169 /* SyntaxKind.TypeReference */:
+            return node.typeName;
+        case 75 /* SyntaxKind.Identifier */:
+        case 153 /* SyntaxKind.QualifiedName */:
+            return node;
+    }
+    return undefined;
+}
+/** A expressão chamada: a de uma chamada, ou a tag de um elemento JSX. Na tag, também a de um template marcado (CK-02). */
+export function getInvokedExpression(node) {
+    switch (node.kind) {
+        case 268 /* SyntaxKind.JsxOpeningElement */:
+        case 267 /* SyntaxKind.JsxSelfClosingElement */:
+            return node.tagName;
+        default:
+            return node.expression;
+    }
+}
+export function isJSXTagName(node) {
+    const { parent } = node;
+    if (parent.kind === 268 /* SyntaxKind.JsxOpeningElement */ ||
+        parent.kind === 267 /* SyntaxKind.JsxSelfClosingElement */ ||
+        parent.kind === 269 /* SyntaxKind.JsxClosingElement */) {
+        return parent.tagName === node;
+    }
+    return false;
+}
+export function isExpressionNode(node) {
+    switch (node.kind) {
+        case 100 /* SyntaxKind.NullKeyword */:
+        case 106 /* SyntaxKind.TrueKeyword */:
+        case 91 /* SyntaxKind.FalseKeyword */:
+        case 192 /* SyntaxKind.ArrayLiteralExpression */:
+        case 193 /* SyntaxKind.ObjectLiteralExpression */:
+        case 194 /* SyntaxKind.PropertyAccessExpression */:
+        case 195 /* SyntaxKind.ElementAccessExpression */:
+        case 196 /* SyntaxKind.CallExpression */:
+        case 217 /* SyntaxKind.AsExpression */:
+        case 200 /* SyntaxKind.ParenthesizedExpression */:
+        case 202 /* SyntaxKind.ArrowFunction */:
+        case 203 /* SyntaxKind.DeleteExpression */:
+        case 204 /* SyntaxKind.TypeOfExpression */:
+        case 207 /* SyntaxKind.PrefixUnaryExpression */:
+        case 208 /* SyntaxKind.PostfixUnaryExpression */:
+        case 209 /* SyntaxKind.BinaryExpression */:
+        case 210 /* SyntaxKind.ConditionalExpression */:
+        case 213 /* SyntaxKind.SpreadElement */:
+        case 211 /* SyntaxKind.TemplateExpression */:
+        case 215 /* SyntaxKind.OmittedExpression */:
+        case 266 /* SyntaxKind.JsxElement */:
+        case 267 /* SyntaxKind.JsxSelfClosingElement */:
+        case 270 /* SyntaxKind.JsxFragment */:
+        case 206 /* SyntaxKind.AwaitExpression */:
+        case 219 /* SyntaxKind.MetaProperty */:
+            return true;
+        case 153 /* SyntaxKind.QualifiedName */:
+            while (node.parent.kind === 153 /* SyntaxKind.QualifiedName */) {
+                node = node.parent;
+            }
+            return node.parent.kind === 172 /* SyntaxKind.TypeQuery */ || isJSXTagName(node);
+        case 75 /* SyntaxKind.Identifier */:
+            if (node.parent.kind === 172 /* SyntaxKind.TypeQuery */ || isJSXTagName(node)) {
+                return true;
+            }
+        // falls through
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+            return isInExpressionContext(node);
+        default:
+            return false;
+    }
+}
+export function isInExpressionContext(node) {
+    const { parent } = node;
+    switch (parent.kind) {
+        case 242 /* SyntaxKind.VariableDeclaration */:
+        case 156 /* SyntaxKind.Parameter */:
+        case 158 /* SyntaxKind.PropertySignature */:
+        case 281 /* SyntaxKind.PropertyAssignment */:
+        case 191 /* SyntaxKind.BindingElement */:
+            return parent.initializer === node;
+        case 226 /* SyntaxKind.ExpressionStatement */:
+        case 227 /* SyntaxKind.IfStatement */:
+        case 228 /* SyntaxKind.DoStatement */:
+        case 229 /* SyntaxKind.WhileStatement */:
+        case 235 /* SyntaxKind.ReturnStatement */:
+        case 237 /* SyntaxKind.SwitchStatement */:
+        case 277 /* SyntaxKind.CaseClause */:
+        case 239 /* SyntaxKind.ThrowStatement */:
+            return parent.expression === node;
+        case 230 /* SyntaxKind.ForStatement */:
+            const forStatement = parent;
+            return (forStatement.initializer === node && forStatement.initializer.kind !== 243 /* SyntaxKind.VariableDeclarationList */) ||
+                forStatement.condition === node ||
+                forStatement.incrementor === node;
+        case 231 /* SyntaxKind.ForInStatement */:
+        case 232 /* SyntaxKind.ForOfStatement */:
+            const forInStatement = parent;
+            return (forInStatement.initializer === node && forInStatement.initializer.kind !== 243 /* SyntaxKind.VariableDeclarationList */) ||
+                forInStatement.expression === node;
+        case 217 /* SyntaxKind.AsExpression */:
+            return node === parent.expression;
+        case 221 /* SyntaxKind.TemplateSpan */:
+            return node === parent.expression;
+        case 154 /* SyntaxKind.ComputedPropertyName */:
+            return node === parent.expression;
+        case 276 /* SyntaxKind.JsxExpression */:
+        case 275 /* SyntaxKind.JsxSpreadAttribute */:
+        case 283 /* SyntaxKind.SpreadAssignment */:
+            return true;
+        case 282 /* SyntaxKind.ShorthandPropertyAssignment */:
+            return parent.objectAssignmentInitializer === node;
+        default:
+            return isExpressionNode(parent);
+    }
+}
+export function isPartOfTypeQuery(node) {
+    while (node.kind === 153 /* SyntaxKind.QualifiedName */ || node.kind === 75 /* SyntaxKind.Identifier */) {
+        node = node.parent;
+    }
+    return node.kind === 172 /* SyntaxKind.TypeQuery */;
+}
+export function isSourceFileJS(file) {
+    return isInJSFile(file);
+}
+export function isInJSFile(node) {
+    return !!node && !!(node.flags & 131072 /* NodeFlags.JavaScriptFile */);
+}
+export function isRequireCall(callExpression, requireStringLiteralLikeArgument) {
+    if (callExpression.kind !== 196 /* SyntaxKind.CallExpression */) {
+        return false;
+    }
+    const { expression, arguments: args } = callExpression;
+    if (expression.kind !== 75 /* SyntaxKind.Identifier */ || expression.escapedText !== "require") {
+        return false;
+    }
+    if (args.length !== 1) {
+        return false;
+    }
+    const arg = args[0];
+    return !requireStringLiteralLikeArgument || isStringLiteralLike(arg);
+}
+export function isSingleOrDoubleQuote(charCode) {
+    return charCode === 39 /* CharacterCodes.singleQuote */ || charCode === 34 /* CharacterCodes.doubleQuote */;
+}
+export function isStringDoubleQuoted(str, sourceFile) {
+    return getSourceTextOfNodeFromSourceFile(sourceFile, str).charCodeAt(0) === 34 /* CharacterCodes.doubleQuote */;
+}
+export function isAssignmentDeclaration(decl) {
+    return isBinaryExpression(decl) || isAccessExpression(decl) || isIdentifier(decl) || isCallExpression(decl);
+}
+export function getEffectiveInitializer(node) {
+    return node.initializer;
+}
+/**
+ * Os inicializadores de expando reconhecidos: a arrow chamada na hora (`(() => {})()`), a arrow, o object literal vazio
+ * e, quando inicializa um protótipo, o object literal com membros.
+ *
+ * Devolve o inicializador, ou `undefined` se ele não for um desses.
+ */
+export function getExpandoInitializer(initializer, isPrototypeAssignment) {
+    if (isCallExpression(initializer)) {
+        const e = skipParentheses(initializer.expression);
+        return e.kind === 202 /* SyntaxKind.ArrowFunction */ ? initializer : undefined;
+    }
+    if (initializer.kind === 202 /* SyntaxKind.ArrowFunction */) {
+        return initializer;
+    }
+    if (isObjectLiteralExpression(initializer) && (initializer.properties.length === 0 || isPrototypeAssignment)) {
+        return initializer;
+    }
+}
+export function isDefaultedExpandoInitializer(node) {
+    const name = isVariableDeclaration(node.parent) ? node.parent.name :
+        isBinaryExpression(node.parent) && node.parent.operatorToken.kind === 62 /* SyntaxKind.EqualsToken */ ? node.parent.left :
+            undefined;
+    return name && getExpandoInitializer(node.right, isPrototypeAccess(name)) && isEntityNameExpression(name) && isSameEntityName(name, node.left);
+}
+/**
+ * Is the 'declared' name the same as the one in the initializer?
+ * @return true for identical entity names, as well as ones where the initializer is prefixed with
+ * 'window', 'self' or 'global'. For example:
+ *
+ * var my = my || {}
+ * var min = window.min || {}
+ * my.app = self.my.app || class { }
+ */
+function isSameEntityName(name, initializer) {
+    if (isPropertyNameLiteral(name) && isPropertyNameLiteral(initializer)) {
+        return getTextOfIdentifierOrLiteral(name) === getTextOfIdentifierOrLiteral(name);
+    }
+    if (isIdentifier(name) && isLiteralLikeAccess(initializer) &&
+        isIdentifier(initializer.expression) &&
+        (initializer.expression.escapedText === "window" ||
+            initializer.expression.escapedText === "self" ||
+            initializer.expression.escapedText === "global")) {
+        return isSameEntityName(name, getNameOrArgument(initializer));
+    }
+    if (isLiteralLikeAccess(name) && isLiteralLikeAccess(initializer)) {
+        return getElementOrPropertyAccessName(name) === getElementOrPropertyAccessName(initializer)
+            && isSameEntityName(name.expression, initializer.expression);
+    }
+    return false;
+}
+export function isExportsIdentifier(node) {
+    return isIdentifier(node) && node.escapedText === "exports";
+}
+export function isModuleIdentifier(node) {
+    return isIdentifier(node) && node.escapedText === "module";
+}
+export function isModuleExportsAccessExpression(node) {
+    return (isPropertyAccessExpression(node) || isLiteralLikeElementAccess(node))
+        && isModuleIdentifier(node.expression)
+        && getElementOrPropertyAccessName(node) === "exports";
+}
+/// Given a BinaryExpression, returns SpecialPropertyAssignmentKind for the various kinds of property
+/// assignments we treat as special in the binder
+export function getAssignmentDeclarationKind(expr) {
+    const special = getAssignmentDeclarationKindWorker(expr);
+    return special === 4 /* AssignmentDeclarationKind.Property */ ? special : 0 /* AssignmentDeclarationKind.None */;
+}
+export function isBindableObjectDefinePropertyCall(expr) {
+    return length(expr.arguments) === 3 &&
+        isPropertyAccessExpression(expr.expression) &&
+        isIdentifier(expr.expression.expression) &&
+        idText(expr.expression.expression) === "Object" &&
+        idText(expr.expression.name) === "defineProperty" &&
+        isStringOrNumericLiteralLike(expr.arguments[1]) &&
+        isBindableStaticNameExpression(expr.arguments[0]);
+}
+/** x.y OR x[0] */
+export function isLiteralLikeAccess(node) {
+    return isPropertyAccessExpression(node) || isLiteralLikeElementAccess(node);
+}
+/** x[0] OR x['a'] OR x[Symbol.y] */
+export function isLiteralLikeElementAccess(node) {
+    return isElementAccessExpression(node) && (isStringOrNumericLiteralLike(node.argumentExpression) ||
+        isWellKnownSymbolSyntactically(node.argumentExpression));
+}
+/** Any series of property and element accesses. */
+export function isBindableStaticAccessExpression(node) {
+    return isPropertyAccessExpression(node) && isIdentifier(node.name) && isBindableStaticNameExpression(node.expression)
+        || isBindableStaticElementAccessExpression(node);
+}
+/** Any series of property and element accesses, ending in a literal element access */
+export function isBindableStaticElementAccessExpression(node) {
+    return isLiteralLikeElementAccess(node)
+        && (isEntityNameExpression(node.expression) ||
+            isBindableStaticAccessExpression(node.expression));
+}
+export function isBindableStaticNameExpression(node) {
+    return isEntityNameExpression(node) || isBindableStaticAccessExpression(node);
+}
+export function getNameOrArgument(expr) {
+    if (isPropertyAccessExpression(expr)) {
+        return expr.name;
+    }
+    return expr.argumentExpression;
+}
+function getAssignmentDeclarationKindWorker(expr) {
+    if (isCallExpression(expr)) {
+        if (!isBindableObjectDefinePropertyCall(expr)) {
+            return 0 /* AssignmentDeclarationKind.None */;
+        }
+        const entityName = expr.arguments[0];
+        if (isExportsIdentifier(entityName) || isModuleExportsAccessExpression(entityName)) {
+            return 7 /* AssignmentDeclarationKind.ObjectDefinePropertyExports */;
+        }
+        if (isBindableStaticAccessExpression(entityName) && getElementOrPropertyAccessName(entityName) === "prototype") {
+            return 8 /* AssignmentDeclarationKind.ObjectDefinePrototypeProperty */;
+        }
+        return 6 /* AssignmentDeclarationKind.ObjectDefinePropertyValue */;
+    }
+    if (expr.operatorToken.kind !== 62 /* SyntaxKind.EqualsToken */ || !isAccessExpression(expr.left)) {
+        return 0 /* AssignmentDeclarationKind.None */;
+    }
+    if (isBindableStaticNameExpression(expr.left.expression) && getElementOrPropertyAccessName(expr.left) === "prototype" && isObjectLiteralExpression(getInitializerOfBinaryExpression(expr))) {
+        // F.prototype = { ... }
+        return 5 /* AssignmentDeclarationKind.Prototype */;
+    }
+    return getAssignmentDeclarationPropertyAccessKind(expr.left);
+}
+/**
+ * Does not handle signed numeric names like `a[+0]` - handling those would require handling prefix unary expressions
+ * throughout late binding handling as well, which is awkward (but ultimately probably doable if there is demand)
+ */
+export function getElementOrPropertyAccessArgumentExpressionOrName(node) {
+    if (isPropertyAccessExpression(node)) {
+        return node.name;
+    }
+    const arg = skipParentheses(node.argumentExpression);
+    if (isNumericLiteral(arg) || isStringLiteralLike(arg)) {
+        return arg;
+    }
+    return node;
+}
+export function getElementOrPropertyAccessName(node) {
+    const name = getElementOrPropertyAccessArgumentExpressionOrName(node);
+    if (name) {
+        if (isIdentifier(name)) {
+            return name.escapedText;
+        }
+        if (isStringLiteralLike(name) || isNumericLiteral(name)) {
+            return escapeLeadingUnderscores(name.text);
+        }
+    }
+    if (isElementAccessExpression(node) && isWellKnownSymbolSyntactically(node.argumentExpression)) {
+        return getPropertyNameForKnownSymbolName(idText(node.argumentExpression.name));
+    }
+    return undefined;
+}
+export function getAssignmentDeclarationPropertyAccessKind(lhs) {
+    if (isModuleExportsAccessExpression(lhs)) {
+        // module.exports = expr
+        return 2 /* AssignmentDeclarationKind.ModuleExports */;
+    }
+    else if (isBindableStaticNameExpression(lhs.expression)) {
+        if (isPrototypeAccess(lhs.expression)) {
+            // F.G....prototype.x = expr
+            return 3 /* AssignmentDeclarationKind.PrototypeProperty */;
+        }
+        let nextToLast = lhs;
+        while (!isIdentifier(nextToLast.expression)) {
+            nextToLast = nextToLast.expression;
+        }
+        const id = nextToLast.expression;
+        if ((id.escapedText === "exports" ||
+            id.escapedText === "module" && getElementOrPropertyAccessName(nextToLast) === "exports") &&
+            // ExportsProperty does not support binding with computed names
+            isBindableStaticAccessExpression(lhs)) {
+            // exports.name = expr OR module.exports.name = expr OR exports["name"] = expr ...
+            return 1 /* AssignmentDeclarationKind.ExportsProperty */;
+        }
+        if (isBindableStaticNameExpression(lhs) || (isElementAccessExpression(lhs) && isDynamicName(lhs))) {
+            // F.G...x = expr
+            return 4 /* AssignmentDeclarationKind.Property */;
+        }
+    }
+    return 0 /* AssignmentDeclarationKind.None */;
+}
+export function getInitializerOfBinaryExpression(expr) {
+    while (isBinaryExpression(expr.right)) {
+        expr = expr.right;
+    }
+    return expr.right;
+}
+export function setValueDeclaration(symbol, node) {
+    const { valueDeclaration } = symbol;
+    if (!valueDeclaration ||
+        !(node.flags & 8388608 /* NodeFlags.Ambient */ && !(valueDeclaration.flags & 8388608 /* NodeFlags.Ambient */)) &&
+            (isAssignmentDeclaration(valueDeclaration) && !isAssignmentDeclaration(node)) ||
+        (valueDeclaration.kind !== node.kind && isEffectiveModuleDeclaration(valueDeclaration))) {
+        // other kinds of value declarations take precedence over modules and assignment declarations
+        symbol.valueDeclaration = node;
+    }
+}
+export function importFromModuleSpecifier(node) {
+    return tryGetImportFromModuleSpecifier(node) || Debug.failBadSyntaxKind(node.parent);
+}
+export function tryGetImportFromModuleSpecifier(node) {
+    switch (node.parent.kind) {
+        case 254 /* SyntaxKind.ImportDeclaration */:
+        case 260 /* SyntaxKind.ExportDeclaration */:
+            return node.parent;
+        // Na tag, também o `require` do `import =` (CK-03).
+        case 196 /* SyntaxKind.CallExpression */:
+            return isImportCall(node.parent) || isRequireCall(node.parent, /*checkArg*/ false) ? node.parent : undefined;
+        case 187 /* SyntaxKind.LiteralType */:
+            Debug.assert(isStringLiteral(node));
+            return tryCast(node.parent.parent, isImportTypeNode);
+        default:
+            return undefined;
+    }
+}
+export function getExternalModuleName(node) {
+    switch (node.kind) {
+        case 254 /* SyntaxKind.ImportDeclaration */:
+        case 260 /* SyntaxKind.ExportDeclaration */:
+            return node.moduleSpecifier;
+        case 188 /* SyntaxKind.ImportType */:
+            return isLiteralImportTypeNode(node) ? node.argument.literal : undefined;
+        default:
+            return Debug.assertNever(node);
+    }
+}
+/** Na tag, também o `import =` (CK-03), que nunca é import default. */
+export function isDefaultImport(node) {
+    return node.kind === 254 /* SyntaxKind.ImportDeclaration */ && !!node.importClause && !!node.importClause.name;
+}
+export function hasQuestionToken(node) {
+    if (node) {
+        switch (node.kind) {
+            case 156 /* SyntaxKind.Parameter */:
+            case 282 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 281 /* SyntaxKind.PropertyAssignment */:
+            case 158 /* SyntaxKind.PropertySignature */:
+                return node.questionToken !== undefined;
+        }
+    }
+    return false;
+}
+/** Na tag, também o inicializador de uma propriedade de classe (CK-02). */
+export function getSingleInitializerOfVariableStatementOrPropertyDeclaration(node) {
+    switch (node.kind) {
+        case 225 /* SyntaxKind.VariableStatement */:
+            const v = getSingleVariableOfVariableStatement(node);
+            return v && v.initializer;
+        case 281 /* SyntaxKind.PropertyAssignment */:
+            return node.initializer;
+    }
+}
+function getSingleVariableOfVariableStatement(node) {
+    return isVariableStatement(node) ? firstOrUndefined(node.declarationList.declarations) : undefined;
+}
+export function hasRestParameter(s) {
+    const last = lastOrUndefined(s.parameters);
+    return !!last && isRestParameter(last);
+}
+export function isRestParameter(node) {
+    return node.dotDotDotToken !== undefined;
+}
+export var AssignmentKind;
+(function (AssignmentKind) {
+    AssignmentKind[AssignmentKind["None"] = 0] = "None";
+    AssignmentKind[AssignmentKind["Definite"] = 1] = "Definite";
+    AssignmentKind[AssignmentKind["Compound"] = 2] = "Compound";
+})(AssignmentKind || (AssignmentKind = {}));
+export function getAssignmentTargetKind(node) {
+    let parent = node.parent;
+    while (true) {
+        switch (parent.kind) {
+            case 209 /* SyntaxKind.BinaryExpression */:
+                const binaryOperator = parent.operatorToken.kind;
+                return isAssignmentOperator(binaryOperator) && parent.left === node ?
+                    binaryOperator === 62 /* SyntaxKind.EqualsToken */ ? 1 /* AssignmentKind.Definite */ : 2 /* AssignmentKind.Compound */ :
+                    0 /* AssignmentKind.None */;
+            case 207 /* SyntaxKind.PrefixUnaryExpression */:
+            case 208 /* SyntaxKind.PostfixUnaryExpression */:
+                const unaryOperator = parent.operator;
+                return unaryOperator === 45 /* SyntaxKind.PlusPlusToken */ || unaryOperator === 46 /* SyntaxKind.MinusMinusToken */ ? 2 /* AssignmentKind.Compound */ : 0 /* AssignmentKind.None */;
+            case 231 /* SyntaxKind.ForInStatement */:
+            case 232 /* SyntaxKind.ForOfStatement */:
+                return parent.initializer === node ? 1 /* AssignmentKind.Definite */ : 0 /* AssignmentKind.None */;
+            case 200 /* SyntaxKind.ParenthesizedExpression */:
+            case 192 /* SyntaxKind.ArrayLiteralExpression */:
+            case 213 /* SyntaxKind.SpreadElement */:
+                node = parent;
+                break;
+            case 282 /* SyntaxKind.ShorthandPropertyAssignment */:
+                if (parent.name !== node) {
+                    return 0 /* AssignmentKind.None */;
+                }
+                node = parent.parent;
+                break;
+            case 281 /* SyntaxKind.PropertyAssignment */:
+                if (parent.name === node) {
+                    return 0 /* AssignmentKind.None */;
+                }
+                node = parent.parent;
+                break;
+            default:
+                return 0 /* AssignmentKind.None */;
+        }
+        parent = node.parent;
+    }
+}
+// A node is an assignment target if it is on the left hand side of an '=' token, if it is parented by a property
+// assignment in an object literal that is an assignment target, or if it is parented by an array literal that is
+// an assignment target. Examples include 'a = xxx', '{ p: a } = xxx', '[{ a }] = xxx'.
+// (Note that `p` is not a target in the above examples, only `a`.)
+export function isAssignmentTarget(node) {
+    return getAssignmentTargetKind(node) !== 0 /* AssignmentKind.None */;
+}
+function walkUp(node, kind) {
+    while (node && node.kind === kind) {
+        node = node.parent;
+    }
+    return node;
+}
+export function walkUpParenthesizedExpressions(node) {
+    return walkUp(node, 200 /* SyntaxKind.ParenthesizedExpression */);
+}
+export function skipParentheses(node) {
+    return skipOuterExpressions(node, 1 /* OuterExpressionKinds.Parentheses */);
+}
+function skipParenthesesUp(node) {
+    while (node.kind === 200 /* SyntaxKind.ParenthesizedExpression */) {
+        node = node.parent;
+    }
+    return node;
+}
+// a node is delete target iff. it is PropertyAccessExpression/ElementAccessExpression with parentheses skipped
+export function isDeleteTarget(node) {
+    if (node.kind !== 194 /* SyntaxKind.PropertyAccessExpression */ && node.kind !== 195 /* SyntaxKind.ElementAccessExpression */) {
+        return false;
+    }
+    node = walkUpParenthesizedExpressions(node.parent);
+    return node && node.kind === 203 /* SyntaxKind.DeleteExpression */;
+}
+export function isNodeDescendantOf(node, ancestor) {
+    while (node) {
+        if (node === ancestor)
+            return true;
+        node = node.parent;
+    }
+    return false;
+}
+// True if `name` is the name of a declaration node
+export function isDeclarationName(name) {
+    return !isSourceFile(name) && !isBindingPattern(name) && isDeclaration(name.parent) && name.parent.name === name;
+}
+/**
+ * A declaração de que o nome é o nome. Na tag, também o parâmetro do JSDoc num nome qualificado (CK-03) e o nome
+ * `#private` (CK-02).
+ */
+export function getDeclarationFromName(name) {
+    const parent = name.parent;
+    switch (name.kind) {
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+            if (isComputedPropertyName(parent))
+                return parent.parent;
+        // falls through
+        case 75 /* SyntaxKind.Identifier */:
+            if (isDeclaration(parent)) {
+                return parent.name === name ? parent : undefined;
+            }
+            else if (isQualifiedName(parent)) {
+                return undefined;
+            }
+            else {
+                const binExp = parent.parent;
+                return isBinaryExpression(binExp) &&
+                    getAssignmentDeclarationKind(binExp) !== 0 /* AssignmentDeclarationKind.None */ &&
+                    (binExp.left.symbol || binExp.symbol) &&
+                    getNameOfDeclaration(binExp) === name
+                    ? binExp
+                    : undefined;
+            }
+        default:
+            return undefined;
+    }
+}
+export function isLiteralComputedPropertyDeclarationName(node) {
+    return isStringOrNumericLiteralLike(node) &&
+        node.parent.kind === 154 /* SyntaxKind.ComputedPropertyName */ &&
+        isDeclaration(node.parent.parent);
+}
+// Return true if the given identifier is classified as an IdentifierName
+export function isIdentifierName(node) {
+    let parent = node.parent;
+    switch (parent.kind) {
+        case 158 /* SyntaxKind.PropertySignature */:
+        case 281 /* SyntaxKind.PropertyAssignment */:
+        case 194 /* SyntaxKind.PropertyAccessExpression */:
+            // Name in member declaration or property name in property access
+            return parent.name === node;
+        case 153 /* SyntaxKind.QualifiedName */:
+            // Name on right hand side of dot in a type query or type reference
+            if (parent.right === node) {
+                while (parent.kind === 153 /* SyntaxKind.QualifiedName */) {
+                    parent = parent.parent;
+                }
+                return parent.kind === 172 /* SyntaxKind.TypeQuery */ || parent.kind === 169 /* SyntaxKind.TypeReference */;
+            }
+            return false;
+        case 191 /* SyntaxKind.BindingElement */:
+        case 258 /* SyntaxKind.ImportSpecifier */:
+            // Property name in binding element or import specifier
+            return parent.propertyName === node;
+        case 263 /* SyntaxKind.ExportSpecifier */:
+        case 273 /* SyntaxKind.JsxAttribute */:
+            // Any name in an export specifier or JSX Attribute
+            return true;
+    }
+    return false;
+}
+/**
+ * A declaração que cria um símbolo alias: `import x from`, `import * as x from`, `import { a as x } from`,
+ * `export { a as x }`, `export * as x from`, `export default` de um nome, e o shorthand e a propriedade de objeto cujo
+ * valor é um nome.
+ */
+export function isAliasSymbolDeclaration(node) {
+    return node.kind === 255 /* SyntaxKind.ImportClause */ && !!node.name ||
+        node.kind === 256 /* SyntaxKind.NamespaceImport */ ||
+        node.kind === 262 /* SyntaxKind.NamespaceExport */ ||
+        node.kind === 258 /* SyntaxKind.ImportSpecifier */ ||
+        node.kind === 263 /* SyntaxKind.ExportSpecifier */ ||
+        node.kind === 259 /* SyntaxKind.ExportAssignment */ && exportAssignmentIsAlias(node) ||
+        isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 2 /* AssignmentDeclarationKind.ModuleExports */ && exportAssignmentIsAlias(node) ||
+        isPropertyAccessExpression(node) && isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 62 /* SyntaxKind.EqualsToken */ && isAliasableExpression(node.parent.right) ||
+        node.kind === 282 /* SyntaxKind.ShorthandPropertyAssignment */ ||
+        node.kind === 281 /* SyntaxKind.PropertyAssignment */ && isAliasableExpression(node.initializer);
+}
+export function getAliasDeclarationFromName(node) {
+    switch (node.parent.kind) {
+        case 255 /* SyntaxKind.ImportClause */:
+        case 258 /* SyntaxKind.ImportSpecifier */:
+        case 256 /* SyntaxKind.NamespaceImport */:
+        case 263 /* SyntaxKind.ExportSpecifier */:
+        case 259 /* SyntaxKind.ExportAssignment */:
+            return node.parent;
+        case 153 /* SyntaxKind.QualifiedName */:
+            do {
+                node = node.parent;
+            } while (node.parent.kind === 153 /* SyntaxKind.QualifiedName */);
+            return getAliasDeclarationFromName(node);
+    }
+}
+export function isAliasableExpression(e) {
+    return isEntityNameExpression(e);
+}
+export function exportAssignmentIsAlias(node) {
+    const e = getExportAssignmentExpression(node);
+    return isAliasableExpression(e);
+}
+export function getExportAssignmentExpression(node) {
+    return isExportAssignment(node) ? node.expression : node.right;
+}
+export function getAncestor(node, kind) {
+    while (node) {
+        if (node.kind === kind) {
+            return node;
+        }
+        node = node.parent;
+    }
+    return undefined;
+}
+export function isKeyword(token) {
+    return 77 /* SyntaxKind.FirstKeyword */ <= token && token <= 152 /* SyntaxKind.LastKeyword */;
+}
+export function isContextualKeyword(token) {
+    return 122 /* SyntaxKind.FirstContextualKeyword */ <= token && token <= 152 /* SyntaxKind.LastContextualKeyword */;
+}
+export function isNonContextualKeyword(token) {
+    return isKeyword(token) && !isContextualKeyword(token);
+}
+export function isStringANonContextualKeyword(name) {
+    const token = stringToToken(name);
+    return token !== undefined && isNonContextualKeyword(token);
+}
+export function isIdentifierANonContextualKeyword({ originalKeywordKind }) {
+    return !!originalKeywordKind && !isContextualKeyword(originalKeywordKind);
+}
+export function isTrivia(token) {
+    return 2 /* SyntaxKind.FirstTriviaToken */ <= token && token <= 7 /* SyntaxKind.LastTriviaToken */;
+}
+export var FunctionFlags;
+(function (FunctionFlags) {
+    FunctionFlags[FunctionFlags["Normal"] = 0] = "Normal";
+    FunctionFlags[FunctionFlags["Async"] = 2] = "Async";
+    FunctionFlags[FunctionFlags["Invalid"] = 4] = "Invalid";
+})(FunctionFlags || (FunctionFlags = {}));
+export function getFunctionFlags(node) {
+    if (!node) {
+        return 4 /* FunctionFlags.Invalid */;
+    }
+    let flags = 0 /* FunctionFlags.Normal */;
+    switch (node.kind) {
+        case 202 /* SyntaxKind.ArrowFunction */:
+            if (hasModifier(node, 256 /* ModifierFlags.Async */)) {
+                flags |= 2 /* FunctionFlags.Async */;
+            }
+            break;
+    }
+    if (!node.body) {
+        flags |= 4 /* FunctionFlags.Invalid */;
+    }
+    return flags;
+}
+export function isAsyncFunction(node) {
+    switch (node.kind) {
+        case 202 /* SyntaxKind.ArrowFunction */:
+            return node.body !== undefined
+                && hasModifier(node, 256 /* ModifierFlags.Async */);
+    }
+    return false;
+}
+export function isStringOrNumericLiteralLike(node) {
+    return isStringLiteralLike(node) || isNumericLiteral(node);
+}
+export function isSignedNumericLiteral(node) {
+    return isPrefixUnaryExpression(node) && (node.operator === 39 /* SyntaxKind.PlusToken */ || node.operator === 40 /* SyntaxKind.MinusToken */) && isNumericLiteral(node.operand);
+}
+/**
+ * A declaration has a dynamic name if all of the following are true:
+ *   1. The declaration has a computed property name.
+ *   2. The computed name is *not* expressed as a StringLiteral.
+ *   3. The computed name is *not* expressed as a NumericLiteral.
+ *   4. The computed name is *not* expressed as a PlusToken or MinusToken
+ *      immediately followed by a NumericLiteral.
+ *   5. The computed name is *not* expressed as `Symbol.<name>`, where `<name>`
+ *      is a property of the Symbol constructor that denotes a built-in
+ *      Symbol.
+ */
+export function hasDynamicName(declaration) {
+    const name = getNameOfDeclaration(declaration);
+    return !!name && isDynamicName(name);
+}
+export function isDynamicName(name) {
+    if (!(name.kind === 154 /* SyntaxKind.ComputedPropertyName */ || name.kind === 195 /* SyntaxKind.ElementAccessExpression */)) {
+        return false;
+    }
+    const expr = isElementAccessExpression(name) ? skipParentheses(name.argumentExpression) : name.expression;
+    return !isStringOrNumericLiteralLike(expr) &&
+        !isSignedNumericLiteral(expr) &&
+        !isWellKnownSymbolSyntactically(expr);
+}
+/**
+ * Checks if the expression is of the form:
+ *    Symbol.name
+ * where Symbol is literally the word "Symbol", and name is any identifierName
+ */
+export function isWellKnownSymbolSyntactically(node) {
+    return isPropertyAccessExpression(node) && isESSymbolIdentifier(node.expression);
+}
+export function getPropertyNameForPropertyNameNode(name) {
+    switch (name.kind) {
+        case 75 /* SyntaxKind.Identifier */:
+            return name.escapedText;
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+            return escapeLeadingUnderscores(name.text);
+        case 154 /* SyntaxKind.ComputedPropertyName */:
+            const nameExpression = name.expression;
+            if (isWellKnownSymbolSyntactically(nameExpression)) {
+                return getPropertyNameForKnownSymbolName(idText(nameExpression.name));
+            }
+            else if (isStringOrNumericLiteralLike(nameExpression)) {
+                return escapeLeadingUnderscores(nameExpression.text);
+            }
+            return undefined;
+        default:
+            return Debug.assertNever(name);
+    }
+}
+export function isPropertyNameLiteral(node) {
+    switch (node.kind) {
+        case 75 /* SyntaxKind.Identifier */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+            return true;
+        default:
+            return false;
+    }
+}
+export function getTextOfIdentifierOrLiteral(node) {
+    return isIdentifier(node) ? idText(node) : node.text;
+}
+export function getEscapedTextOfIdentifierOrLiteral(node) {
+    return isIdentifier(node) ? node.escapedText : escapeLeadingUnderscores(node.text);
+}
+export function getPropertyNameForKnownSymbolName(symbolName) {
+    return "__@" + symbolName;
+}
+export function isKnownSymbol(symbol) {
+    return startsWith(symbol.escapedName, "__@");
+}
+/**
+ * Includes the word "Symbol" with unicode escapes
+ */
+export function isESSymbolIdentifier(node) {
+    return node.kind === 75 /* SyntaxKind.Identifier */ && node.escapedText === "Symbol";
+}
+export function isParameterDeclaration(node) {
+    const root = getRootDeclaration(node);
+    return root.kind === 156 /* SyntaxKind.Parameter */;
+}
+export function getRootDeclaration(node) {
+    while (node.kind === 191 /* SyntaxKind.BindingElement */) {
+        node = node.parent.parent;
+    }
+    return node;
+}
+export function nodeIsSynthesized(range) {
+    return positionIsSynthesized(range.pos)
+        || positionIsSynthesized(range.end);
+}
+export var Associativity;
+(function (Associativity) {
+    Associativity[Associativity["Left"] = 0] = "Left";
+    Associativity[Associativity["Right"] = 1] = "Right";
+})(Associativity || (Associativity = {}));
+export function getExpressionAssociativity(expression) {
+    const operator = getOperator(expression);
+    return getOperatorAssociativity(expression.kind, operator);
+}
+export function getOperatorAssociativity(kind, operator) {
+    switch (kind) {
+        case 207 /* SyntaxKind.PrefixUnaryExpression */:
+        case 204 /* SyntaxKind.TypeOfExpression */:
+        case 203 /* SyntaxKind.DeleteExpression */:
+        case 206 /* SyntaxKind.AwaitExpression */:
+        case 210 /* SyntaxKind.ConditionalExpression */:
+            return 1 /* Associativity.Right */;
+        case 209 /* SyntaxKind.BinaryExpression */:
+            switch (operator) {
+                case 42 /* SyntaxKind.AsteriskAsteriskToken */:
+                case 62 /* SyntaxKind.EqualsToken */:
+                case 63 /* SyntaxKind.PlusEqualsToken */:
+                case 64 /* SyntaxKind.MinusEqualsToken */:
+                case 66 /* SyntaxKind.AsteriskAsteriskEqualsToken */:
+                case 65 /* SyntaxKind.AsteriskEqualsToken */:
+                case 67 /* SyntaxKind.SlashEqualsToken */:
+                case 68 /* SyntaxKind.PercentEqualsToken */:
+                case 69 /* SyntaxKind.LessThanLessThanEqualsToken */:
+                case 70 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */:
+                case 71 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */:
+                case 72 /* SyntaxKind.AmpersandEqualsToken */:
+                case 74 /* SyntaxKind.CaretEqualsToken */:
+                case 73 /* SyntaxKind.BarEqualsToken */:
+                    return 1 /* Associativity.Right */;
+            }
+    }
+    return 0 /* Associativity.Left */;
+}
+export function getExpressionPrecedence(expression) {
+    const operator = getOperator(expression);
+    return getOperatorPrecedence(expression.kind, operator);
+}
+export function getOperator(expression) {
+    if (expression.kind === 209 /* SyntaxKind.BinaryExpression */) {
+        return expression.operatorToken.kind;
+    }
+    else if (expression.kind === 207 /* SyntaxKind.PrefixUnaryExpression */ || expression.kind === 208 /* SyntaxKind.PostfixUnaryExpression */) {
+        return expression.operator;
+    }
+    else {
+        return expression.kind;
+    }
+}
+export function getOperatorPrecedence(nodeKind, operatorKind) {
+    switch (nodeKind) {
+        case 327 /* SyntaxKind.CommaListExpression */:
+            return 0;
+        case 213 /* SyntaxKind.SpreadElement */:
+            return 1;
+        case 210 /* SyntaxKind.ConditionalExpression */:
+            return 4;
+        case 209 /* SyntaxKind.BinaryExpression */:
+            switch (operatorKind) {
+                case 27 /* SyntaxKind.CommaToken */:
+                    return 0;
+                case 62 /* SyntaxKind.EqualsToken */:
+                case 63 /* SyntaxKind.PlusEqualsToken */:
+                case 64 /* SyntaxKind.MinusEqualsToken */:
+                case 66 /* SyntaxKind.AsteriskAsteriskEqualsToken */:
+                case 65 /* SyntaxKind.AsteriskEqualsToken */:
+                case 67 /* SyntaxKind.SlashEqualsToken */:
+                case 68 /* SyntaxKind.PercentEqualsToken */:
+                case 69 /* SyntaxKind.LessThanLessThanEqualsToken */:
+                case 70 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */:
+                case 71 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */:
+                case 72 /* SyntaxKind.AmpersandEqualsToken */:
+                case 74 /* SyntaxKind.CaretEqualsToken */:
+                case 73 /* SyntaxKind.BarEqualsToken */:
+                    return 3;
+                default:
+                    return getBinaryOperatorPrecedence(operatorKind);
+            }
+        case 207 /* SyntaxKind.PrefixUnaryExpression */:
+        case 204 /* SyntaxKind.TypeOfExpression */:
+        case 203 /* SyntaxKind.DeleteExpression */:
+        case 206 /* SyntaxKind.AwaitExpression */:
+            return 16;
+        case 208 /* SyntaxKind.PostfixUnaryExpression */:
+            return 17;
+        case 196 /* SyntaxKind.CallExpression */:
+            return 18;
+        case 194 /* SyntaxKind.PropertyAccessExpression */:
+        case 195 /* SyntaxKind.ElementAccessExpression */:
+            return 19;
+        case 75 /* SyntaxKind.Identifier */:
+        case 100 /* SyntaxKind.NullKeyword */:
+        case 106 /* SyntaxKind.TrueKeyword */:
+        case 91 /* SyntaxKind.FalseKeyword */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 192 /* SyntaxKind.ArrayLiteralExpression */:
+        case 193 /* SyntaxKind.ObjectLiteralExpression */:
+        case 202 /* SyntaxKind.ArrowFunction */:
+        case 266 /* SyntaxKind.JsxElement */:
+        case 267 /* SyntaxKind.JsxSelfClosingElement */:
+        case 270 /* SyntaxKind.JsxFragment */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 211 /* SyntaxKind.TemplateExpression */:
+        case 200 /* SyntaxKind.ParenthesizedExpression */:
+        case 215 /* SyntaxKind.OmittedExpression */:
+            return 20;
+        default:
+            return -1;
+    }
+}
+export function getBinaryOperatorPrecedence(kind) {
+    switch (kind) {
+        // O `??` tem a precedência do `||`, e não a do condicional.
+        case 60 /* SyntaxKind.QuestionQuestionToken */:
+        case 56 /* SyntaxKind.BarBarToken */:
+            return 5;
+        case 55 /* SyntaxKind.AmpersandAmpersandToken */:
+            return 6;
+        case 51 /* SyntaxKind.BarToken */:
+            return 7;
+        case 52 /* SyntaxKind.CaretToken */:
+            return 8;
+        case 50 /* SyntaxKind.AmpersandToken */:
+            return 9;
+        // A igualdade da Linguagem é o `==` e o `!=`, com o significado do `===` e do `!==` da tag (CK-70); o `===` e o
+        // `!==` não são operador, e o parser não os lê.
+        case 34 /* SyntaxKind.EqualsEqualsToken */:
+        case 35 /* SyntaxKind.ExclamationEqualsToken */:
+            return 10;
+        case 29 /* SyntaxKind.LessThanToken */:
+        case 31 /* SyntaxKind.GreaterThanToken */:
+        case 32 /* SyntaxKind.LessThanEqualsToken */:
+        case 33 /* SyntaxKind.GreaterThanEqualsToken */:
+        case 97 /* SyntaxKind.InKeyword */:
+        case 123 /* SyntaxKind.AsKeyword */:
+            return 11;
+        case 47 /* SyntaxKind.LessThanLessThanToken */:
+        case 48 /* SyntaxKind.GreaterThanGreaterThanToken */:
+        case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */:
+            return 12;
+        case 39 /* SyntaxKind.PlusToken */:
+        case 40 /* SyntaxKind.MinusToken */:
+            return 13;
+        case 41 /* SyntaxKind.AsteriskToken */:
+        case 43 /* SyntaxKind.SlashToken */:
+        case 44 /* SyntaxKind.PercentToken */:
+            return 14;
+        case 42 /* SyntaxKind.AsteriskAsteriskToken */:
+            return 15;
+    }
+    // -1 is lower than all other precedences.  Returning it will cause binary expression
+    // parsing to stop.
+    return -1;
+}
+const templateSubstitutionRegExp = /\$\{/g;
+function escapeTemplateSubstitution(str) {
+    return str.replace(templateSubstitutionRegExp, "\\${");
+}
+// This consists of the first 19 unprintable ASCII characters, canonical escapes, lineSeparator,
+// paragraphSeparator, and nextLine. The latter three are just desirable to suppress new lines in
+// the language service. These characters should be escaped when printing, and if any characters are added,
+// the map below must be updated. Note that this regexp *does not* include the 'delete' character.
+// There is no reason for this other than that JSON.stringify does not handle it either.
+const doubleQuoteEscapedCharsRegExp = /[\\\"\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
+const singleQuoteEscapedCharsRegExp = /[\\\'\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
+// O template guarda o LF simples, e escapa os outros caracteres de controle; o CRLF e o CR, relidos, virariam LF.
+const backtickQuoteEscapedCharsRegExp = /\r\n|[\\`\u0000-\u0009\u000b-\u001f\u2028\u2029\u0085]/g;
+const escapedCharsMap = createMapFromTemplate({
+    "\t": "\\t",
+    "\v": "\\v",
+    "\f": "\\f",
+    "\b": "\\b",
+    "\r": "\\r",
+    "\n": "\\n",
+    "\\": "\\\\",
+    "\"": "\\\"",
+    "\'": "\\\'",
+    "\`": "\\\`",
+    "\u2028": "\\u2028", // lineSeparator
+    "\u2029": "\\u2029", // paragraphSeparator
+    "\u0085": "\\u0085", // nextLine
+    "\r\n": "\\r\\n", // o CRLF num template
+});
+function encodeUtf16EscapeSequence(charCode) {
+    const hexCharCode = charCode.toString(16).toUpperCase();
+    const paddedHexCode = ("0000" + hexCharCode).slice(-4);
+    return "\\u" + paddedHexCode;
+}
+function getReplacement(c, offset, input) {
+    if (c.charCodeAt(0) === 0 /* CharacterCodes.nullCharacter */) {
+        const lookAhead = input.charCodeAt(offset + c.length);
+        if (lookAhead >= 48 /* CharacterCodes._0 */ && lookAhead <= 57 /* CharacterCodes._9 */) {
+            // If the null character is followed by digits, print as a hex escape to prevent the result from parsing as an octal (which is forbidden in strict mode)
+            return "\\x00";
+        }
+        // Otherwise, keep printing a literal \0 for the null character
+        return "\\0";
+    }
+    return escapedCharsMap.get(c) || encodeUtf16EscapeSequence(c.charCodeAt(0));
+}
+/**
+ * Based heavily on the abstract 'Quote'/'QuoteJSONString' operation from ECMA-262 (24.3.2.2),
+ * but augmented for a few select characters (e.g. lineSeparator, paragraphSeparator, nextLine)
+ * Note that this doesn't actually wrap the input in double quotes.
+ */
+export function escapeString(s, quoteChar) {
+    const escapedCharsRegExp = quoteChar === 96 /* CharacterCodes.backtick */ ? backtickQuoteEscapedCharsRegExp :
+        quoteChar === 39 /* CharacterCodes.singleQuote */ ? singleQuoteEscapedCharsRegExp :
+            doubleQuoteEscapedCharsRegExp;
+    return s.replace(escapedCharsRegExp, getReplacement);
+}
+const nonAsciiCharacters = /[^\u0000-\u007F]/g;
+export function escapeNonAsciiString(s, quoteChar) {
+    s = escapeString(s, quoteChar);
+    // Replace non-ASCII characters with '\uNNNN' escapes if any exist.
+    // Otherwise just return the original string.
+    return nonAsciiCharacters.test(s) ?
+        s.replace(nonAsciiCharacters, c => encodeUtf16EscapeSequence(c.charCodeAt(0))) :
+        s;
+}
+// This consists of the first 19 unprintable ASCII characters, JSX canonical escapes, lineSeparator,
+// paragraphSeparator, and nextLine. The latter three are just desirable to suppress new lines in
+// the language service. These characters should be escaped when printing, and if any characters are added,
+// the map below must be updated.
+const jsxDoubleQuoteEscapedCharsRegExp = /[\"\u0000-\u001f\u2028\u2029\u0085]/g;
+const jsxSingleQuoteEscapedCharsRegExp = /[\'\u0000-\u001f\u2028\u2029\u0085]/g;
+const jsxEscapedCharsMap = createMapFromTemplate({
+    "\"": "&quot;",
+    "\'": "&apos;"
+});
+function encodeJsxCharacterEntity(charCode) {
+    const hexCharCode = charCode.toString(16).toUpperCase();
+    return "&#x" + hexCharCode + ";";
+}
+function getJsxAttributeStringReplacement(c) {
+    if (c.charCodeAt(0) === 0 /* CharacterCodes.nullCharacter */) {
+        return "&#0;";
+    }
+    return jsxEscapedCharsMap.get(c) || encodeJsxCharacterEntity(c.charCodeAt(0));
+}
+export function escapeJsxAttributeString(s, quoteChar) {
+    const escapedCharsRegExp = quoteChar === 39 /* CharacterCodes.singleQuote */ ? jsxSingleQuoteEscapedCharsRegExp :
+        jsxDoubleQuoteEscapedCharsRegExp;
+    return s.replace(escapedCharsRegExp, getJsxAttributeStringReplacement);
+}
+/** O texto sem as aspas simples, as duplas ou as crases que o cercam, quando as duas pontas são iguais. */
+export function stripQuotes(name) {
+    const length = name.length;
+    if (length >= 2 && name.charCodeAt(0) === name.charCodeAt(length - 1) && isQuoteOrBacktick(name.charCodeAt(0))) {
+        return name.substring(1, length - 1);
+    }
+    return name;
+}
+function isQuoteOrBacktick(charCode) {
+    return charCode === 39 /* CharacterCodes.singleQuote */ ||
+        charCode === 34 /* CharacterCodes.doubleQuote */ ||
+        charCode === 96 /* CharacterCodes.backtick */;
+}
+export function isIntrinsicJsxName(name) {
+    const ch = name.charCodeAt(0);
+    return (ch >= 97 /* CharacterCodes.a */ && ch <= 122 /* CharacterCodes.z */) || stringContains(name, "-");
+}
+const indentStrings = ["", "    "];
+export function getIndentString(level) {
+    if (indentStrings[level] === undefined) {
+        indentStrings[level] = getIndentString(level - 1) + indentStrings[1];
+    }
+    return indentStrings[level];
+}
+export function getIndentSize() {
+    return indentStrings[1].length;
+}
+export function hostUsesCaseSensitiveFileNames(host) {
+    return host.useCaseSensitiveFileNames ? host.useCaseSensitiveFileNames() : false;
+}
+export function getLineOfLocalPosition(sourceFile, pos) {
+    const lineStarts = getLineStarts(sourceFile);
+    return computeLineOfPosition(lineStarts, pos);
+}
+export function getLineOfLocalPositionFromLineMap(lineMap, pos) {
+    return computeLineOfPosition(lineMap, pos);
+}
+/** A anotação de tipo de uma variável, de um parâmetro ou de uma propriedade. */
+export function getEffectiveTypeAnnotationNode(node) {
+    return node.type;
+}
+/** A anotação do retorno de uma assinatura. */
+export function getEffectiveReturnTypeNode(node) {
+    return node.type;
+}
+export function hasModifiers(node) {
+    return getModifierFlags(node) !== 0 /* ModifierFlags.None */;
+}
+export function hasModifier(node, flags) {
+    return !!getSelectedModifierFlags(node, flags);
+}
+export function hasReadonlyModifier(node) {
+    return hasModifier(node, 64 /* ModifierFlags.Readonly */);
+}
+export function getSelectedModifierFlags(node, flags) {
+    return getModifierFlags(node) & flags;
+}
+export function getModifierFlags(node) {
+    if (node.kind >= 0 /* SyntaxKind.FirstToken */ && node.kind <= 152 /* SyntaxKind.LastToken */) {
+        return 0 /* ModifierFlags.None */;
+    }
+    if (node.modifierFlagsCache & 536870912 /* ModifierFlags.HasComputedFlags */) {
+        return node.modifierFlagsCache & ~536870912 /* ModifierFlags.HasComputedFlags */;
+    }
+    const flags = getModifierFlagsNoCache(node);
+    node.modifierFlagsCache = flags | 536870912 /* ModifierFlags.HasComputedFlags */;
+    return flags;
+}
+export function getModifierFlagsNoCache(node) {
+    let flags = 0 /* ModifierFlags.None */;
+    if (node.modifiers) {
+        for (const modifier of node.modifiers) {
+            flags |= modifierToFlag(modifier.kind);
+        }
+    }
+    if (node.flags & 4 /* NodeFlags.NestedNamespace */) {
+        flags |= 1 /* ModifierFlags.Export */;
+    }
+    return flags;
+}
+export function modifierToFlag(token) {
+    switch (token) {
+        case 89 /* SyntaxKind.ExportKeyword */: return 1 /* ModifierFlags.Export */;
+        case 130 /* SyntaxKind.DeclareKeyword */: return 2 /* ModifierFlags.Ambient */;
+        case 126 /* SyntaxKind.AsyncKeyword */: return 256 /* ModifierFlags.Async */;
+        case 138 /* SyntaxKind.ReadonlyKeyword */: return 64 /* ModifierFlags.Readonly */;
+    }
+    return 0 /* ModifierFlags.None */;
+}
+export function isAssignmentOperator(token) {
+    return token >= 62 /* SyntaxKind.FirstAssignment */ && token <= 74 /* SyntaxKind.LastAssignment */;
+}
+export function isAssignmentExpression(node, excludeCompoundAssignment) {
+    return isBinaryExpression(node)
+        && (excludeCompoundAssignment
+            ? node.operatorToken.kind === 62 /* SyntaxKind.EqualsToken */
+            : isAssignmentOperator(node.operatorToken.kind))
+        && isLeftHandSideExpression(node.left);
+}
+export function isEntityNameExpression(node) {
+    return node.kind === 75 /* SyntaxKind.Identifier */ || isPropertyAccessEntityNameExpression(node);
+}
+export function getFirstIdentifier(node) {
+    switch (node.kind) {
+        case 75 /* SyntaxKind.Identifier */:
+            return node;
+        case 153 /* SyntaxKind.QualifiedName */:
+            do {
+                node = node.left;
+            } while (node.kind !== 75 /* SyntaxKind.Identifier */);
+            return node;
+        case 194 /* SyntaxKind.PropertyAccessExpression */:
+            do {
+                node = node.expression;
+            } while (node.kind !== 75 /* SyntaxKind.Identifier */);
+            return node;
+    }
+}
+export function isDottedName(node) {
+    return node.kind === 75 /* SyntaxKind.Identifier */ ||
+        node.kind === 194 /* SyntaxKind.PropertyAccessExpression */ && isDottedName(node.expression) ||
+        node.kind === 200 /* SyntaxKind.ParenthesizedExpression */ && isDottedName(node.expression);
+}
+export function isPropertyAccessEntityNameExpression(node) {
+    return isPropertyAccessExpression(node) && isIdentifier(node.name) && isEntityNameExpression(node.expression);
+}
+export function tryGetPropertyAccessOrIdentifierToString(expr) {
+    if (isPropertyAccessExpression(expr)) {
+        const baseStr = tryGetPropertyAccessOrIdentifierToString(expr.expression);
+        if (baseStr !== undefined) {
+            return baseStr + "." + expr.name;
+        }
+    }
+    else if (isIdentifier(expr)) {
+        return unescapeLeadingUnderscores(expr.escapedText);
+    }
+    return undefined;
+}
+export function isPrototypeAccess(node) {
+    return isBindableStaticAccessExpression(node) && getElementOrPropertyAccessName(node) === "prototype";
+}
+export function isRightSideOfQualifiedNameOrPropertyAccess(node) {
+    return (node.parent.kind === 153 /* SyntaxKind.QualifiedName */ && node.parent.right === node) ||
+        (node.parent.kind === 194 /* SyntaxKind.PropertyAccessExpression */ && node.parent.name === node);
+}
+export function isEmptyArrayLiteral(expression) {
+    return expression.kind === 192 /* SyntaxKind.ArrayLiteralExpression */ &&
+        expression.elements.length === 0;
+}
+/** Return ".ts", ".d.ts", or ".tsx", if that is the extension. */
+export function tryExtractTSExtension(fileName) {
+    return find(supportedTSExtensionsForExtractExtension, extension => fileExtensionIs(fileName, extension));
+}
+export function createRange(pos, end = pos) {
+    Debug.assert(end >= pos || end === -1);
+    return { pos, end };
+}
+export function rangeIsOnSingleLine(range, sourceFile) {
+    return rangeStartIsOnSameLineAsRangeEnd(range, range, sourceFile);
+}
+export function rangeStartPositionsAreOnSameLine(range1, range2, sourceFile) {
+    return positionsAreOnSameLine(getStartPositionOfRange(range1, sourceFile, /*includeComments*/ false), getStartPositionOfRange(range2, sourceFile, /*includeComments*/ false), sourceFile);
+}
+export function rangeEndPositionsAreOnSameLine(range1, range2, sourceFile) {
+    return positionsAreOnSameLine(range1.end, range2.end, sourceFile);
+}
+export function rangeStartIsOnSameLineAsRangeEnd(range1, range2, sourceFile) {
+    return positionsAreOnSameLine(getStartPositionOfRange(range1, sourceFile, /*includeComments*/ false), range2.end, sourceFile);
+}
+export function rangeEndIsOnSameLineAsRangeStart(range1, range2, sourceFile) {
+    return positionsAreOnSameLine(range1.end, getStartPositionOfRange(range2, sourceFile, /*includeComments*/ false), sourceFile);
+}
+export function getLinesBetweenRangeEndAndRangeStart(range1, range2, sourceFile, includeSecondRangeComments) {
+    const range2Start = getStartPositionOfRange(range2, sourceFile, includeSecondRangeComments);
+    return getLinesBetweenPositions(sourceFile, range1.end, range2Start);
+}
+export function isNodeArrayMultiLine(list, sourceFile) {
+    return !positionsAreOnSameLine(list.pos, list.end, sourceFile);
+}
+export function positionsAreOnSameLine(pos1, pos2, sourceFile) {
+    return getLinesBetweenPositions(sourceFile, pos1, pos2) === 0;
+}
+export function getStartPositionOfRange(range, sourceFile, includeComments) {
+    return positionIsSynthesized(range.pos) ? -1 : skipTrivia(sourceFile.text, range.pos, /*stopAfterLineBreak*/ false, includeComments);
+}
+export function getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter(pos, stopPos, sourceFile, includeComments) {
+    const startPos = skipTrivia(sourceFile.text, pos, /*stopAfterLineBreak*/ false, includeComments);
+    const prevPos = getPreviousNonWhitespacePosition(startPos, stopPos, sourceFile);
+    return getLinesBetweenPositions(sourceFile, prevPos ?? stopPos, startPos);
+}
+export function getLinesBetweenPositionAndNextNonWhitespaceCharacter(pos, stopPos, sourceFile, includeComments) {
+    const nextPos = skipTrivia(sourceFile.text, pos, /*stopAfterLineBreak*/ false, includeComments);
+    return getLinesBetweenPositions(sourceFile, pos, Math.min(stopPos, nextPos));
+}
+function getPreviousNonWhitespacePosition(pos, stopPos = 0, sourceFile) {
+    while (pos-- > stopPos) {
+        if (!isWhiteSpaceLike(sourceFile.text.charCodeAt(pos))) {
+            return pos;
+        }
+    }
+}
+/**
+ * Os modificadores da declaração de valor do símbolo. A propriedade sintética de uma união e o protótipo não têm
+ * declaração, e a acessibilidade e o `static` que o `tsc` dava a eles eram da classe.
+ */
+export function getDeclarationModifierFlagsFromSymbol(s) {
+    return s.valueDeclaration ? getCombinedModifierFlags(s.valueDeclaration) : 0;
+}
+/**
+ * As flags do símbolo somadas às do exportado dele: o membro exportado de um módulo ganha um símbolo local só com o
+ * `ExportValue`, e as flags de verdade ficam no de exportação (o `declareModuleMember` do binder).
+ */
+export function getCombinedLocalAndExportSymbolFlags(symbol) {
+    return symbol.exportSymbol ? symbol.exportSymbol.flags | symbol.flags : symbol.flags;
+}
+export function isWriteOnlyAccess(node) {
+    return accessKind(node) === 1 /* AccessKind.Write */;
+}
+export function isWriteAccess(node) {
+    return accessKind(node) !== 0 /* AccessKind.Read */;
+}
+var AccessKind;
+(function (AccessKind) {
+    /** Only reads from a variable. */
+    AccessKind[AccessKind["Read"] = 0] = "Read";
+    /** Only writes to a variable without using the result. E.g.: `x++;`. */
+    AccessKind[AccessKind["Write"] = 1] = "Write";
+    /** Writes to a variable and uses the result as an expression. E.g.: `f(x++);`. */
+    AccessKind[AccessKind["ReadWrite"] = 2] = "ReadWrite";
+})(AccessKind || (AccessKind = {}));
+function accessKind(node) {
+    const { parent } = node;
+    if (!parent)
+        return 0 /* AccessKind.Read */;
+    switch (parent.kind) {
+        case 200 /* SyntaxKind.ParenthesizedExpression */:
+            return accessKind(parent);
+        case 208 /* SyntaxKind.PostfixUnaryExpression */:
+        case 207 /* SyntaxKind.PrefixUnaryExpression */:
+            const { operator } = parent;
+            return operator === 45 /* SyntaxKind.PlusPlusToken */ || operator === 46 /* SyntaxKind.MinusMinusToken */ ? writeOrReadWrite() : 0 /* AccessKind.Read */;
+        case 209 /* SyntaxKind.BinaryExpression */:
+            const { left, operatorToken } = parent;
+            return left === node && isAssignmentOperator(operatorToken.kind) ?
+                operatorToken.kind === 62 /* SyntaxKind.EqualsToken */ ? 1 /* AccessKind.Write */ : writeOrReadWrite()
+                : 0 /* AccessKind.Read */;
+        case 194 /* SyntaxKind.PropertyAccessExpression */:
+            return parent.name !== node ? 0 /* AccessKind.Read */ : accessKind(parent);
+        case 281 /* SyntaxKind.PropertyAssignment */: {
+            const parentAccess = accessKind(parent.parent);
+            // In `({ x: varname }) = { x: 1 }`, the left `x` is a read, the right `x` is a write.
+            return node === parent.name ? reverseAccessKind(parentAccess) : parentAccess;
+        }
+        case 282 /* SyntaxKind.ShorthandPropertyAssignment */:
+            // Assume it's the local variable being accessed, since we don't check public properties for --noUnusedLocals.
+            return node === parent.objectAssignmentInitializer ? 0 /* AccessKind.Read */ : accessKind(parent.parent);
+        case 192 /* SyntaxKind.ArrayLiteralExpression */:
+            return accessKind(parent);
+        default:
+            return 0 /* AccessKind.Read */;
+    }
+    function writeOrReadWrite() {
+        // If grandparent is not an ExpressionStatement, this is used as an expression in addition to having a side effect.
+        return parent.parent && skipParenthesesUp(parent.parent).kind === 226 /* SyntaxKind.ExpressionStatement */ ? 1 /* AccessKind.Write */ : 2 /* AccessKind.ReadWrite */;
+    }
+}
+function reverseAccessKind(a) {
+    switch (a) {
+        case 0 /* AccessKind.Read */:
+            return 1 /* AccessKind.Write */;
+        case 1 /* AccessKind.Write */:
+            return 0 /* AccessKind.Read */;
+        case 2 /* AccessKind.ReadWrite */:
+            return 2 /* AccessKind.ReadWrite */;
+        default:
+            return Debug.assertNever(a);
+    }
+}
+export function compareDataObjects(dst, src) {
+    if (!dst || !src || Object.keys(dst).length !== Object.keys(src).length) {
+        return false;
+    }
+    for (const e in dst) {
+        if (typeof dst[e] === "object") {
+            if (!compareDataObjects(dst[e], src[e])) {
+                return false;
+            }
+        }
+        else if (typeof dst[e] !== "function") {
+            if (dst[e] !== src[e]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+export function showModuleSpecifier({ moduleSpecifier }) {
+    return isStringLiteral(moduleSpecifier) ? moduleSpecifier.text : getTextOfNode(moduleSpecifier);
+}
+export function getLastChild(node) {
+    let lastChild;
+    forEachChild(node, child => {
+        if (nodeIsPresent(child))
+            lastChild = child;
+    }, children => {
+        // As an optimization, jump straight to the end of the list.
+        for (let i = children.length - 1; i >= 0; i--) {
+            if (nodeIsPresent(children[i])) {
+                lastChild = children[i];
+                break;
+            }
+        }
+    });
+    return lastChild;
+}
+export function addToSeen(seen, key, value = true) {
+    key = String(key);
+    if (seen.has(key)) {
+        return false;
+    }
+    seen.set(key, value);
+    return true;
+}
+export function isObjectTypeDeclaration(node) {
+    // Na tag, também a classe e a interface (CK-02).
+    return isTypeLiteralNode(node);
+}
+export function isTypeNodeKind(kind) {
+    return (kind >= 168 /* SyntaxKind.FirstTypeNode */ && kind <= 188 /* SyntaxKind.LastTypeNode */)
+        || kind === 125 /* SyntaxKind.AnyKeyword */
+        || kind === 148 /* SyntaxKind.UnknownKeyword */
+        || kind === 140 /* SyntaxKind.NumberKeyword */
+        || kind === 151 /* SyntaxKind.BigIntKeyword */
+        || kind === 141 /* SyntaxKind.ObjectKeyword */
+        || kind === 128 /* SyntaxKind.BooleanKeyword */
+        || kind === 143 /* SyntaxKind.StringKeyword */
+        || kind === 144 /* SyntaxKind.SymbolKeyword */
+        || kind === 110 /* SyntaxKind.VoidKeyword */
+        || kind === 146 /* SyntaxKind.UndefinedKeyword */
+        || kind === 100 /* SyntaxKind.NullKeyword */
+        || kind === 137 /* SyntaxKind.NeverKeyword */;
+}
+export function isAccessExpression(node) {
+    return node.kind === 194 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 195 /* SyntaxKind.ElementAccessExpression */;
+}
+export function isNamedImportsOrExports(node) {
+    return node.kind === 257 /* SyntaxKind.NamedImports */ || node.kind === 261 /* SyntaxKind.NamedExports */;
+}
+function Symbol(flags, name) {
+    this.flags = flags;
+    this.escapedName = name;
+    this.declarations = undefined;
+    this.valueDeclaration = undefined;
+    this.id = undefined;
+    this.mergeId = undefined;
+    this.parent = undefined;
+}
+function Node(kind, pos, end) {
+    this.pos = pos;
+    this.end = end;
+    this.kind = kind;
+    this.id = 0;
+    this.flags = 0 /* NodeFlags.None */;
+    this.modifierFlagsCache = 0 /* ModifierFlags.None */;
+    this.transformFlags = 0 /* TransformFlags.None */;
+    this.parent = undefined;
+    this.original = undefined;
+}
+function Token(kind, pos, end) {
+    this.pos = pos;
+    this.end = end;
+    this.kind = kind;
+    this.id = 0;
+    this.flags = 0 /* NodeFlags.None */;
+    this.transformFlags = 0 /* TransformFlags.None */;
+    this.parent = undefined;
+}
+function Identifier(kind, pos, end) {
+    this.pos = pos;
+    this.end = end;
+    this.kind = kind;
+    this.id = 0;
+    this.flags = 0 /* NodeFlags.None */;
+    this.transformFlags = 0 /* TransformFlags.None */;
+    this.parent = undefined;
+    this.original = undefined;
+    this.flowNode = undefined;
+}
+function SourceMapSource(fileName, text, skipTrivia) {
+    this.fileName = fileName;
+    this.text = text;
+    this.skipTrivia = skipTrivia || (pos => pos);
+}
+export let objectAllocator = {
+    getNodeConstructor: () => Node,
+    getTokenConstructor: () => Token,
+    getIdentifierConstructor: () => Identifier,
+    getSourceFileConstructor: () => Node,
+    getSymbolConstructor: () => Symbol,
+    getSourceMapSourceConstructor: () => SourceMapSource,
+};
+/**
+ * Troca os construtores da árvore. O language service troca os de cada nó e o do símbolo pelos dele, que têm os métodos
+ * que os serviços chamam (`node.getStart()`, `symbol.getDocumentationComment()`), ao carregar.
+ */
+export function setObjectAllocator(alloc) {
+    objectAllocator = alloc;
+}
+export function formatStringFromArgs(text, args, baseIndex = 0) {
+    return text.replace(/{(\d+)}/g, (_match, index) => "" + Debug.checkDefined(args[+index + baseIndex]));
+}
+export let localizedDiagnosticMessages;
+export function setLocalizedDiagnosticMessages(messages) {
+    localizedDiagnosticMessages = messages;
+}
+export function getLocaleSpecificMessage(message) {
+    return localizedDiagnosticMessages && localizedDiagnosticMessages[message.key] || message.message;
+}
+export function createFileDiagnostic(file, start, length, message) {
+    Debug.assertGreaterThanOrEqual(start, 0);
+    Debug.assertGreaterThanOrEqual(length, 0);
+    if (file) {
+        Debug.assertLessThanOrEqual(start, file.text.length);
+        Debug.assertLessThanOrEqual(start + length, file.text.length);
+    }
+    let text = getLocaleSpecificMessage(message);
+    if (arguments.length > 4) {
+        text = formatStringFromArgs(text, arguments, 4);
+    }
+    return {
+        file,
+        start,
+        length,
+        messageText: text,
+        category: message.category,
+        code: message.code,
+        reportsUnnecessary: message.reportsUnnecessary,
+    };
+}
+export function formatMessage(_dummy, message) {
+    let text = getLocaleSpecificMessage(message);
+    if (arguments.length > 2) {
+        text = formatStringFromArgs(text, arguments, 2);
+    }
+    return text;
+}
+export function createCompilerDiagnostic(message) {
+    let text = getLocaleSpecificMessage(message);
+    if (arguments.length > 1) {
+        text = formatStringFromArgs(text, arguments, 1);
+    }
+    return {
+        file: undefined,
+        start: undefined,
+        length: undefined,
+        messageText: text,
+        category: message.category,
+        code: message.code,
+        reportsUnnecessary: message.reportsUnnecessary,
+    };
+}
+export function chainDiagnosticMessages(details, message) {
+    let text = getLocaleSpecificMessage(message);
+    if (arguments.length > 2) {
+        text = formatStringFromArgs(text, arguments, 2);
+    }
+    return {
+        messageText: text,
+        category: message.category,
+        code: message.code,
+        next: details === undefined || Array.isArray(details) ? details : [details]
+    };
+}
+export function concatenateDiagnosticMessageChains(headChain, tailChain) {
+    let lastChain = headChain;
+    while (lastChain.next) {
+        lastChain = lastChain.next[0];
+    }
+    lastChain.next = [tailChain];
+}
+/** O texto inteiro de uma mensagem encadeada: cada elo numa linha, indentado de dois em dois espaços pela profundidade. */
+export function flattenDiagnosticMessageText(diag, newLine, indent = 0) {
+    if (isString(diag)) {
+        return diag;
+    }
+    else if (diag === undefined) {
+        return "";
+    }
+    let result = "";
+    if (indent) {
+        result += newLine;
+        for (let i = 0; i < indent; i++) {
+            result += "  ";
+        }
+    }
+    result += diag.messageText;
+    indent++;
+    if (diag.next) {
+        for (const kid of diag.next) {
+            result += flattenDiagnosticMessageText(kid, newLine, indent);
+        }
+    }
+    return result;
+}
+function getDiagnosticFilePath(diagnostic) {
+    return diagnostic.file ? diagnostic.file.path : undefined;
+}
+export function compareDiagnostics(d1, d2) {
+    return compareDiagnosticsSkipRelatedInformation(d1, d2) ||
+        compareRelatedInformation(d1, d2) ||
+        0 /* Comparison.EqualTo */;
+}
+export function compareDiagnosticsSkipRelatedInformation(d1, d2) {
+    return compareStringsCaseSensitive(getDiagnosticFilePath(d1), getDiagnosticFilePath(d2)) ||
+        compareValues(d1.start, d2.start) ||
+        compareValues(d1.length, d2.length) ||
+        compareValues(d1.code, d2.code) ||
+        compareMessageText(d1.messageText, d2.messageText) ||
+        0 /* Comparison.EqualTo */;
+}
+function compareRelatedInformation(d1, d2) {
+    if (!d1.relatedInformation && !d2.relatedInformation) {
+        return 0 /* Comparison.EqualTo */;
+    }
+    if (d1.relatedInformation && d2.relatedInformation) {
+        return compareValues(d1.relatedInformation.length, d2.relatedInformation.length) || forEach(d1.relatedInformation, (d1i, index) => {
+            const d2i = d2.relatedInformation[index];
+            return compareDiagnostics(d1i, d2i); // EqualTo is 0, so falsy, and will cause the next item to be compared
+        }) || 0 /* Comparison.EqualTo */;
+    }
+    return d1.relatedInformation ? -1 /* Comparison.LessThan */ : 1 /* Comparison.GreaterThan */;
+}
+function compareMessageText(t1, t2) {
+    if (typeof t1 === "string" && typeof t2 === "string") {
+        return compareStringsCaseSensitive(t1, t2);
+    }
+    else if (typeof t1 === "string") {
+        return -1 /* Comparison.LessThan */;
+    }
+    else if (typeof t2 === "string") {
+        return 1 /* Comparison.GreaterThan */;
+    }
+    let res = compareStringsCaseSensitive(t1.messageText, t2.messageText);
+    if (res) {
+        return res;
+    }
+    if (!t1.next && !t2.next) {
+        return 0 /* Comparison.EqualTo */;
+    }
+    if (!t1.next) {
+        return -1 /* Comparison.LessThan */;
+    }
+    if (!t2.next) {
+        return 1 /* Comparison.GreaterThan */;
+    }
+    const len = Math.min(t1.next.length, t2.next.length);
+    for (let i = 0; i < len; i++) {
+        res = compareMessageText(t1.next[i], t2.next[i]);
+        if (res) {
+            return res;
+        }
+    }
+    if (t1.next.length < t2.next.length) {
+        return -1 /* Comparison.LessThan */;
+    }
+    else if (t1.next.length > t2.next.length) {
+        return 1 /* Comparison.GreaterThan */;
+    }
+    return 0 /* Comparison.EqualTo */;
+}
+export function unreachableCodeIsError(options) {
+    return options.allowUnreachableCode === false;
+}
+function stripLeadingDirectorySeparator(s) {
+    return isAnyDirectorySeparator(s.charCodeAt(0)) ? s.slice(1) : undefined;
+}
+export function tryRemoveDirectoryPrefix(path, dirPath, getCanonicalFileName) {
+    const withoutPrefix = tryRemovePrefix(path, dirPath, getCanonicalFileName);
+    return withoutPrefix === undefined ? undefined : stripLeadingDirectorySeparator(withoutPrefix);
+}
+export function ensureScriptKind(fileName, scriptKind) {
+    // Using scriptKind as a condition handles both:
+    // - 'scriptKind' is unspecified and thus it is `undefined`
+    // - 'scriptKind' is set and it is `Unknown` (0)
+    // If the 'scriptKind' is 'undefined' or 'Unknown' then we attempt
+    // to get the ScriptKind from the file name. If it cannot be resolved
+    // from the file name then the default 'TS' script kind is returned.
+    return scriptKind || getScriptKindFromFileName(fileName) || 3 /* ScriptKind.TS */;
+}
+export function getScriptKindFromFileName(fileName) {
+    const ext = fileName.substr(fileName.lastIndexOf("."));
+    switch (ext.toLowerCase()) {
+        case ".js" /* Extension.Js */:
+            return 1 /* ScriptKind.JS */;
+        case ".jsx" /* Extension.Jsx */:
+            return 2 /* ScriptKind.JSX */;
+        case ".ts" /* Extension.Ts */:
+            return 3 /* ScriptKind.TS */;
+        case ".tsx" /* Extension.Tsx */:
+            return 4 /* ScriptKind.TSX */;
+        case ".json" /* Extension.Json */:
+            return 6 /* ScriptKind.JSON */;
+        default:
+            return 0 /* ScriptKind.Unknown */;
+    }
+}
+/** Must have ".d.ts" first because if ".ts" goes first, that will be detected as the extension instead of ".d.ts". */
+export const supportedTSExtensionsForExtractExtension = [".d.ts" /* Extension.Dts */, ".ts" /* Extension.Ts */, ".tsx" /* Extension.Tsx */];
+export const supportedJSExtensions = [".js" /* Extension.Js */, ".jsx" /* Extension.Jsx */];
+export function hasJSFileExtension(fileName) {
+    return some(supportedJSExtensions, extension => fileExtensionIs(fileName, extension));
+}
+const extensionsToRemove = [".d.ts" /* Extension.Dts */, ".ts" /* Extension.Ts */, ".js" /* Extension.Js */, ".tsx" /* Extension.Tsx */, ".jsx" /* Extension.Jsx */, ".json" /* Extension.Json */];
+export function removeFileExtension(path) {
+    for (const ext of extensionsToRemove) {
+        const extensionless = tryRemoveExtension(path, ext);
+        if (extensionless !== undefined) {
+            return extensionless;
+        }
+    }
+    return path;
+}
+export function tryRemoveExtension(path, extension) {
+    return fileExtensionIs(path, extension) ? removeExtension(path, extension) : undefined;
+}
+export function removeExtension(path, extension) {
+    return path.substring(0, path.length - extension.length);
+}
+export function positionIsSynthesized(pos) {
+    // This is a fast way of testing the following conditions:
+    //  pos === undefined || pos === null || isNaN(pos) || pos < 0;
+    return !(pos >= 0);
+}
+/** True if an extension is one of the supported TypeScript extensions. */
+export function extensionIsTS(ext) {
+    return ext === ".ts" /* Extension.Ts */ || ext === ".tsx" /* Extension.Tsx */ || ext === ".d.ts" /* Extension.Dts */;
+}
+export function resolutionExtensionIsTSOrJson(ext) {
+    return extensionIsTS(ext) || ext === ".json" /* Extension.Json */;
+}
+/**
+ * O diagnóstico de um módulo resolvido que a extensão não deixa entrar no programa, ou `undefined`. Os parâmetros dele
+ * são o nome do módulo importado e o arquivo a que resolveu; vale também para o módulo que fica sem tipo.
+ */
+export function getResolutionDiagnostic({ extension }) {
+    switch (extension) {
+        case ".ts" /* Extension.Ts */:
+        case ".d.ts" /* Extension.Dts */:
+        // O JSX não depende de opção (CK-19): o `.tsx` entra como o `.ts`.
+        case ".tsx" /* Extension.Tsx */:
+            return undefined;
+        // Na configuração fixa (CK-24, CK-47), o `allowJs` e o `resolveJsonModule` são desligados, e o `noImplicitAny`
+        // é ligado: o JavaScript e o JSON resolvidos não entram.
+        case ".jsx" /* Extension.Jsx */:
+        case ".js" /* Extension.Js */:
+            return Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type;
+        case ".json" /* Extension.Json */:
+            return Diagnostics.Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used;
+    }
+}
+/**
+ * Gets the extension from a path.
+ * Path must have a valid extension.
+ */
+export function extensionFromPath(path) {
+    const ext = tryGetExtensionFromPath(path);
+    return ext !== undefined ? ext : Debug.fail(`File ${path} has unknown extension.`);
+}
+export function tryGetExtensionFromPath(path) {
+    return find(extensionsToRemove, e => fileExtensionIs(path, e));
+}
+export function sliceAfter(arr, value) {
+    const index = arr.indexOf(value);
+    Debug.assert(index !== -1);
+    return arr.slice(index);
+}
+export function addRelatedInfo(diagnostic, ...relatedInformation) {
+    if (!relatedInformation.length) {
+        return diagnostic;
+    }
+    if (!diagnostic.relatedInformation) {
+        diagnostic.relatedInformation = [];
+    }
+    diagnostic.relatedInformation.push(...relatedInformation);
+    return diagnostic;
+}
+export function minAndMax(arr, getValue) {
+    Debug.assert(arr.length !== 0);
+    let min = getValue(arr[0]);
+    let max = min;
+    for (let i = 1; i < arr.length; i++) {
+        const value = getValue(arr[i]);
+        if (value < min) {
+            min = value;
+        }
+        else if (value > max) {
+            max = value;
+        }
+    }
+    return { min, max };
+}
+export class NodeSet {
+    map = createMap();
+    add(node) {
+        this.map.set(String(getNodeId(node)), node);
+    }
+    tryAdd(node) {
+        if (this.has(node))
+            return false;
+        this.add(node);
+        return true;
+    }
+    has(node) {
+        return this.map.has(String(getNodeId(node)));
+    }
+    forEach(cb) {
+        this.map.forEach(cb);
+    }
+    some(pred) {
+        return forEachEntry(this.map, pred) || false;
+    }
+}
+export class NodeMap {
+    map = createMap();
+    get(node) {
+        const res = this.map.get(String(getNodeId(node)));
+        return res && res.value;
+    }
+    getOrUpdate(node, setValue) {
+        const res = this.get(node);
+        if (res)
+            return res;
+        const value = setValue();
+        this.set(node, value);
+        return value;
+    }
+    set(node, value) {
+        this.map.set(String(getNodeId(node)), { node, value });
+    }
+    has(node) {
+        return this.map.has(String(getNodeId(node)));
+    }
+    forEach(cb) {
+        this.map.forEach(({ node, value }) => cb(value, node));
+    }
+}
+export function rangeOfNode(node) {
+    return { pos: getTokenPosOfNode(node), end: node.end };
+}
+export function rangeOfTypeParameters(typeParameters) {
+    // Include the `<>`
+    return { pos: typeParameters.pos - 1, end: typeParameters.end + 1 };
+}
+/**
+ * Se o arquivo fica sem checagem: o que tem a diretiva `/// <reference no-default-lib="true"/>`, a lib, que se usa e
+ * não se checa (o `skipDefaultLibCheck` da configuração fixa, CK-24; o `skipLibCheck` é desligado).
+ */
+export function skipTypeChecking(sourceFile) {
+    return sourceFile.hasNoDefaultLib;
+}
+export function getOrUpdate(map, key, getDefault) {
+    const got = map.get(key);
+    if (got === undefined) {
+        const value = getDefault();
+        map.set(key, value);
+        return value;
+    }
+    else {
+        return got;
+    }
+}
+/**
+ * Converts a bigint literal string, e.g. `0x1234n`,
+ * to its decimal string representation, e.g. `4660`.
+ */
+export function parsePseudoBigInt(stringValue) {
+    let log2Base;
+    switch (stringValue.charCodeAt(1)) { // "x" in "0x123"
+        case 98 /* CharacterCodes.b */:
+        case 66 /* CharacterCodes.B */: // 0b or 0B
+            log2Base = 1;
+            break;
+        case 111 /* CharacterCodes.o */:
+        case 79 /* CharacterCodes.O */: // 0o or 0O
+            log2Base = 3;
+            break;
+        case 120 /* CharacterCodes.x */:
+        case 88 /* CharacterCodes.X */: // 0x or 0X
+            log2Base = 4;
+            break;
+        default: // already in decimal; omit trailing "n"
+            const nIndex = stringValue.length - 1;
+            // Skip leading 0s
+            let nonZeroStart = 0;
+            while (stringValue.charCodeAt(nonZeroStart) === 48 /* CharacterCodes._0 */) {
+                nonZeroStart++;
+            }
+            return stringValue.slice(nonZeroStart, nIndex) || "0";
+    }
+    // Omit leading "0b", "0o", or "0x", and trailing "n"
+    const startIndex = 2, endIndex = stringValue.length - 1;
+    const bitsNeeded = (endIndex - startIndex) * log2Base;
+    // Stores the value specified by the string as a LE array of 16-bit integers
+    // using Uint16 instead of Uint32 so combining steps can use bitwise operators
+    const segments = new Uint16Array((bitsNeeded >>> 4) + (bitsNeeded & 15 ? 1 : 0));
+    // Add the digits, one at a time
+    for (let i = endIndex - 1, bitOffset = 0; i >= startIndex; i--, bitOffset += log2Base) {
+        const segment = bitOffset >>> 4;
+        const digitChar = stringValue.charCodeAt(i);
+        // Find character range: 0-9 < A-F < a-f
+        const digit = digitChar <= 57 /* CharacterCodes._9 */
+            ? digitChar - 48 /* CharacterCodes._0 */
+            : 10 + digitChar -
+                (digitChar <= 70 /* CharacterCodes.F */ ? 65 /* CharacterCodes.A */ : 97 /* CharacterCodes.a */);
+        const shiftedDigit = digit << (bitOffset & 15);
+        segments[segment] |= shiftedDigit;
+        const residual = shiftedDigit >>> 16;
+        if (residual)
+            segments[segment + 1] |= residual; // overflows segment
+    }
+    // Repeatedly divide segments by 10 and add remainder to base10Value
+    let base10Value = "";
+    let firstNonzeroSegment = segments.length - 1;
+    let segmentsRemaining = true;
+    while (segmentsRemaining) {
+        let mod10 = 0;
+        segmentsRemaining = false;
+        for (let segment = firstNonzeroSegment; segment >= 0; segment--) {
+            const newSegment = mod10 << 16 | segments[segment];
+            const segmentValue = (newSegment / 10) | 0;
+            segments[segment] = segmentValue;
+            mod10 = newSegment - segmentValue * 10;
+            if (segmentValue && !segmentsRemaining) {
+                firstNonzeroSegment = segment;
+                segmentsRemaining = true;
+            }
+        }
+        base10Value = mod10 + base10Value;
+    }
+    return base10Value;
+}
+export function pseudoBigIntToString({ negative, base10Value }) {
+    return (negative && base10Value !== "0" ? "-" : "") + base10Value;
+}
+export function isValidTypeOnlyAliasUseSite(useSite) {
+    return !!(useSite.flags & 8388608 /* NodeFlags.Ambient */)
+        || isPartOfTypeQuery(useSite)
+        || isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(useSite)
+        || !isExpressionNode(useSite);
+}
+export function typeOnlyDeclarationIsExport(typeOnlyDeclaration) {
+    return typeOnlyDeclaration.kind === 263 /* SyntaxKind.ExportSpecifier */;
+}
+function isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(node) {
+    while (node.kind === 75 /* SyntaxKind.Identifier */ || node.kind === 194 /* SyntaxKind.PropertyAccessExpression */) {
+        node = node.parent;
+    }
+    if (node.kind !== 154 /* SyntaxKind.ComputedPropertyName */) {
+        return false;
+    }
+    const containerKind = node.parent.parent.kind;
+    return containerKind === 173 /* SyntaxKind.TypeLiteral */;
+}
+export function isIdentifierTypeReference(node) {
+    return isTypeReferenceNode(node) && isIdentifier(node.typeName);
+}
+export function arrayIsHomogeneous(array, comparer = equateValues) {
+    if (array.length < 2)
+        return true;
+    const first = array[0];
+    for (let i = 1, length = array.length; i < length; i++) {
+        const target = array[i];
+        if (!comparer(first, target))
+            return false;
+    }
+    return true;
+}