@tslite/parser 1.10.0 → 1.13.0

package/dist/utilitiesPublic.js

@@ -0,0 +1,1049 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/utilitiesPublic.ts: o namespace virou módulo ES, com os imports explícitos.
+import { compareDiagnostics, emptyArray, every, getAssignmentDeclarationKind, getElementOrPropertyAccessArgumentExpressionOrName, getModifierFlags, isBindableStaticElementAccessExpression, isFunctionBlock, isRootedDiskPath, isTypeNodeKind, pathIsRelative, skipOuterExpressions, some, sortAndDeduplicate, } from "./_namespaces/ts.js";
+export function isExternalModuleNameRelative(moduleName) {
+    // TypeScript 1.0 spec (April 2014): 11.2.1
+    // An external module name is "relative" if the first term is "." or "..".
+    // Update: We also consider a path like `C:\foo.ts` "relative" because we do not search for it in `node_modules` or treat it as an ambient module.
+    return pathIsRelative(moduleName) || isRootedDiskPath(moduleName);
+}
+export function sortAndDeduplicateDiagnostics(diagnostics) {
+    return sortAndDeduplicate(diagnostics, compareDiagnostics);
+}
+export function getDefaultLibFileName(options) {
+    switch (options.target) {
+        case 99 /* ScriptTarget.ESNext */:
+            return "lib.esnext.full.d.ts";
+        case 7 /* ScriptTarget.ES2020 */:
+            return "lib.es2020.full.d.ts";
+        case 6 /* ScriptTarget.ES2019 */:
+            return "lib.es2019.full.d.ts";
+        case 5 /* ScriptTarget.ES2018 */:
+            return "lib.es2018.full.d.ts";
+        case 4 /* ScriptTarget.ES2017 */:
+            return "lib.es2017.full.d.ts";
+        case 3 /* ScriptTarget.ES2016 */:
+            return "lib.es2016.full.d.ts";
+        case 2 /* ScriptTarget.ES2015 */:
+            return "lib.es6.d.ts"; // We don't use lib.es2015.full.d.ts due to breaking change.
+        default:
+            return "lib.d.ts";
+    }
+}
+export function textSpanEnd(span) {
+    return span.start + span.length;
+}
+export function textSpanIsEmpty(span) {
+    return span.length === 0;
+}
+export function textSpanContainsPosition(span, position) {
+    return position >= span.start && position < textSpanEnd(span);
+}
+export function textSpanIntersectsWith(span, start, length) {
+    return decodedTextSpanIntersectsWith(span.start, span.length, start, length);
+}
+export function decodedTextSpanIntersectsWith(start1, length1, start2, length2) {
+    const end1 = start1 + length1;
+    const end2 = start2 + length2;
+    return start2 <= end1 && end2 >= start1;
+}
+export function textSpanIntersectsWithPosition(span, position) {
+    return position <= textSpanEnd(span) && position >= span.start;
+}
+export function createTextSpan(start, length) {
+    if (start < 0) {
+        throw new Error("start < 0");
+    }
+    if (length < 0) {
+        throw new Error("length < 0");
+    }
+    return { start, length };
+}
+export function createTextSpanFromBounds(start, end) {
+    return createTextSpan(start, end - start);
+}
+export function textChangeRangeNewSpan(range) {
+    return createTextSpan(range.span.start, range.newLength);
+}
+export function textChangeRangeIsUnchanged(range) {
+    return textSpanIsEmpty(range.span) && range.newLength === 0;
+}
+export function createTextChangeRange(span, newLength) {
+    if (newLength < 0) {
+        throw new Error("newLength < 0");
+    }
+    return { span, newLength };
+}
+export function isEmptyBindingPattern(node) {
+    if (isBindingPattern(node)) {
+        return every(node.elements, isEmptyBindingElement);
+    }
+    return false;
+}
+export function isEmptyBindingElement(node) {
+    if (isOmittedExpression(node)) {
+        return true;
+    }
+    return isEmptyBindingPattern(node.name);
+}
+export function walkUpBindingElementsAndPatterns(binding) {
+    let node = binding.parent;
+    while (isBindingElement(node.parent)) {
+        node = node.parent.parent;
+    }
+    return node.parent;
+}
+function getCombinedFlags(node, getFlags) {
+    if (isBindingElement(node)) {
+        node = walkUpBindingElementsAndPatterns(node);
+    }
+    let flags = getFlags(node);
+    if (node.kind === 242 /* SyntaxKind.VariableDeclaration */) {
+        node = node.parent;
+    }
+    if (node && node.kind === 243 /* SyntaxKind.VariableDeclarationList */) {
+        flags |= getFlags(node);
+        node = node.parent;
+    }
+    if (node && node.kind === 225 /* SyntaxKind.VariableStatement */) {
+        flags |= getFlags(node);
+    }
+    return flags;
+}
+export function getCombinedModifierFlags(node) {
+    return getCombinedFlags(node, getModifierFlags);
+}
+// Returns the node flags for this node and all relevant parent nodes.  This is done so that
+// nodes like variable declarations and binding elements can returned a view of their flags
+// that includes the modifiers from their container.  i.e. flags like export/declare aren't
+// stored on the variable declaration directly, but on the containing variable statement
+// (if it has one).  Similarly, flags for let/const are store on the variable declaration
+// list.  By calling this function, all those flags are combined so that the client can treat
+// the node as if it actually had those flags.
+export function getCombinedNodeFlags(node) {
+    return getCombinedFlags(node, n => n.flags);
+}
+export function getOriginalNode(node, nodeTest) {
+    if (node) {
+        while (node.original !== undefined) {
+            node = node.original;
+        }
+    }
+    // O teste recebe o nó como a tag o passa, mesmo `undefined`; o tipo é o do TypeScript 5.
+    return !nodeTest || nodeTest(node) ? node : undefined;
+}
+/**
+ * Gets a value indicating whether a node originated in the parse tree.
+ *
+ * @param node The node to test.
+ */
+export function isParseTreeNode(node) {
+    return (node.flags & 8 /* NodeFlags.Synthesized */) === 0;
+}
+export function getParseTreeNode(node, nodeTest) {
+    if (node === undefined || isParseTreeNode(node)) {
+        return node;
+    }
+    node = getOriginalNode(node);
+    if (isParseTreeNode(node) && (!nodeTest || nodeTest(node))) {
+        return node;
+    }
+    return undefined;
+}
+/** Add an extra underscore to identifiers that start with two underscores to avoid issues with magic names like '__proto__' */
+export function escapeLeadingUnderscores(identifier) {
+    return (identifier.length >= 2 && identifier.charCodeAt(0) === 95 /* CharacterCodes._ */ && identifier.charCodeAt(1) === 95 /* CharacterCodes._ */ ? "_" + identifier : identifier);
+}
+/**
+ * Remove extra underscore from escaped identifier text content.
+ *
+ * @param identifier The escaped identifier text.
+ * @returns The unescaped identifier text.
+ */
+export function unescapeLeadingUnderscores(identifier) {
+    const id = identifier;
+    return id.length >= 3 && id.charCodeAt(0) === 95 /* CharacterCodes._ */ && id.charCodeAt(1) === 95 /* CharacterCodes._ */ && id.charCodeAt(2) === 95 /* CharacterCodes._ */ ? id.substr(1) : id;
+}
+export function idText(identifierOrPrivateName) {
+    return unescapeLeadingUnderscores(identifierOrPrivateName.escapedText);
+}
+export function symbolName(symbol) {
+    return unescapeLeadingUnderscores(symbol.escapedName);
+}
+export function nodeHasName(statement, name) {
+    if (isNamedDeclaration(statement) && isIdentifier(statement.name) && idText(statement.name) === idText(name)) {
+        return true;
+    }
+    if (isVariableStatement(statement) && some(statement.declarationList.declarations, d => nodeHasName(d, name))) {
+        return true;
+    }
+    return false;
+}
+export function isNamedDeclaration(node) {
+    return !!node.name; // A 'name' property should always be a DeclarationName.
+}
+export function getNonAssignedNameOfDeclaration(declaration) {
+    switch (declaration.kind) {
+        case 75 /* SyntaxKind.Identifier */:
+            return declaration;
+        case 196 /* SyntaxKind.CallExpression */:
+        case 209 /* SyntaxKind.BinaryExpression */: {
+            const expr = declaration;
+            switch (getAssignmentDeclarationKind(expr)) {
+                case 1 /* AssignmentDeclarationKind.ExportsProperty */:
+                case 4 /* AssignmentDeclarationKind.Property */:
+                case 3 /* AssignmentDeclarationKind.PrototypeProperty */:
+                    return getElementOrPropertyAccessArgumentExpressionOrName(expr.left);
+                case 6 /* AssignmentDeclarationKind.ObjectDefinePropertyValue */:
+                case 7 /* AssignmentDeclarationKind.ObjectDefinePropertyExports */:
+                case 8 /* AssignmentDeclarationKind.ObjectDefinePrototypeProperty */:
+                    return expr.arguments[1];
+                default:
+                    return undefined;
+            }
+        }
+        case 259 /* SyntaxKind.ExportAssignment */: {
+            const { expression } = declaration;
+            return isIdentifier(expression) ? expression : undefined;
+        }
+        case 195 /* SyntaxKind.ElementAccessExpression */:
+            const expr = declaration;
+            if (isBindableStaticElementAccessExpression(expr)) {
+                return expr.argumentExpression;
+            }
+    }
+    return declaration.name;
+}
+export function getNameOfDeclaration(declaration) {
+    if (declaration === undefined)
+        return undefined;
+    return getNonAssignedNameOfDeclaration(declaration);
+}
+/** Os parâmetros de tipo que a declaração escreve. */
+export function getEffectiveTypeParameterDeclarations(node) {
+    return node.typeParameters || emptyArray;
+}
+/** A constraint que o parâmetro de tipo escreve. */
+export function getEffectiveConstraintOfTypeParameter(node) {
+    return node.constraint;
+}
+// #region
+// Simple node tests of the form `node.kind === SyntaxKind.Foo`.
+// Literals
+export function isNumericLiteral(node) {
+    return node.kind === 8 /* SyntaxKind.NumericLiteral */;
+}
+export function isBigIntLiteral(node) {
+    return node.kind === 9 /* SyntaxKind.BigIntLiteral */;
+}
+export function isStringLiteral(node) {
+    return node.kind === 10 /* SyntaxKind.StringLiteral */;
+}
+export function isJsxText(node) {
+    return node.kind === 11 /* SyntaxKind.JsxText */;
+}
+// Pseudo-literals
+export function isTemplateHead(node) {
+    return node.kind === 15 /* SyntaxKind.TemplateHead */;
+}
+export function isTemplateTail(node) {
+    return node.kind === 17 /* SyntaxKind.TemplateTail */;
+}
+export function isIdentifier(node) {
+    return node.kind === 75 /* SyntaxKind.Identifier */;
+}
+// Names
+export function isQualifiedName(node) {
+    return node.kind === 153 /* SyntaxKind.QualifiedName */;
+}
+export function isComputedPropertyName(node) {
+    return node.kind === 154 /* SyntaxKind.ComputedPropertyName */;
+}
+// Signature elements
+export function isTypeParameterDeclaration(node) {
+    return node.kind === 155 /* SyntaxKind.TypeParameter */;
+}
+export function isParameter(node) {
+    return node.kind === 156 /* SyntaxKind.Parameter */;
+}
+// TypeMember
+export function isPropertySignature(node) {
+    return node.kind === 158 /* SyntaxKind.PropertySignature */;
+}
+export function isMethodSignature(node) {
+    return node.kind === 160 /* SyntaxKind.MethodSignature */;
+}
+export function isCallSignatureDeclaration(node) {
+    return node.kind === 165 /* SyntaxKind.CallSignature */;
+}
+export function isIndexSignatureDeclaration(node) {
+    return node.kind === 167 /* SyntaxKind.IndexSignature */;
+}
+// Type
+export function isTypePredicateNode(node) {
+    return node.kind === 168 /* SyntaxKind.TypePredicate */;
+}
+export function isTypeReferenceNode(node) {
+    return node.kind === 169 /* SyntaxKind.TypeReference */;
+}
+export function isFunctionTypeNode(node) {
+    return node.kind === 170 /* SyntaxKind.FunctionType */;
+}
+export function isTypeQueryNode(node) {
+    return node.kind === 172 /* SyntaxKind.TypeQuery */;
+}
+export function isTypeLiteralNode(node) {
+    return node.kind === 173 /* SyntaxKind.TypeLiteral */;
+}
+export function isArrayTypeNode(node) {
+    return node.kind === 174 /* SyntaxKind.ArrayType */;
+}
+export function isUnionTypeNode(node) {
+    return node.kind === 178 /* SyntaxKind.UnionType */;
+}
+export function isConditionalTypeNode(node) {
+    return node.kind === 180 /* SyntaxKind.ConditionalType */;
+}
+export function isInferTypeNode(node) {
+    return node.kind === 181 /* SyntaxKind.InferType */;
+}
+export function isParenthesizedTypeNode(node) {
+    return node.kind === 182 /* SyntaxKind.ParenthesizedType */;
+}
+export function isTypeOperatorNode(node) {
+    return node.kind === 184 /* SyntaxKind.TypeOperator */;
+}
+export function isIndexedAccessTypeNode(node) {
+    return node.kind === 185 /* SyntaxKind.IndexedAccessType */;
+}
+export function isMappedTypeNode(node) {
+    return node.kind === 186 /* SyntaxKind.MappedType */;
+}
+export function isLiteralTypeNode(node) {
+    return node.kind === 187 /* SyntaxKind.LiteralType */;
+}
+export function isImportTypeNode(node) {
+    return node.kind === 188 /* SyntaxKind.ImportType */;
+}
+// Binding patterns
+export function isObjectBindingPattern(node) {
+    return node.kind === 189 /* SyntaxKind.ObjectBindingPattern */;
+}
+export function isArrayBindingPattern(node) {
+    return node.kind === 190 /* SyntaxKind.ArrayBindingPattern */;
+}
+export function isBindingElement(node) {
+    return node.kind === 191 /* SyntaxKind.BindingElement */;
+}
+// Expression
+export function isArrayLiteralExpression(node) {
+    return node.kind === 192 /* SyntaxKind.ArrayLiteralExpression */;
+}
+export function isObjectLiteralExpression(node) {
+    return node.kind === 193 /* SyntaxKind.ObjectLiteralExpression */;
+}
+export function isPropertyAccessExpression(node) {
+    return node.kind === 194 /* SyntaxKind.PropertyAccessExpression */;
+}
+export function isPropertyAccessChain(node) {
+    return isPropertyAccessExpression(node) && !!(node.flags & 32 /* NodeFlags.OptionalChain */);
+}
+export function isElementAccessExpression(node) {
+    return node.kind === 195 /* SyntaxKind.ElementAccessExpression */;
+}
+export function isCallExpression(node) {
+    return node.kind === 196 /* SyntaxKind.CallExpression */;
+}
+export function isCallChain(node) {
+    return isCallExpression(node) && !!(node.flags & 32 /* NodeFlags.OptionalChain */);
+}
+export function isOptionalChain(node) {
+    const kind = node.kind;
+    return !!(node.flags & 32 /* NodeFlags.OptionalChain */) &&
+        (kind === 194 /* SyntaxKind.PropertyAccessExpression */
+            || kind === 195 /* SyntaxKind.ElementAccessExpression */
+            || kind === 196 /* SyntaxKind.CallExpression */);
+}
+export function isOptionalChainRoot(node) {
+    return isOptionalChain(node) && !!node.questionDotToken;
+}
+/**
+ * Determines whether a node is the expression preceding an optional chain (i.e. `a` in `a?.b`).
+ */
+export function isExpressionOfOptionalChainRoot(node) {
+    return isOptionalChainRoot(node.parent) && node.parent.expression === node;
+}
+/**
+ * Determines whether a node is the outermost `OptionalChain` in an ECMAScript `OptionalExpression`:
+ *
+ * 1. For `a?.b.c`, the outermost chain is `a?.b.c` (`c` is the end of the chain starting at `a?.`)
+ * 2. For `a?.b!`, the outermost chain is `a?.b` (`b` is the end of the chain starting at `a?.`)
+ * 3. For `(a?.b.c).d`, the outermost chain is `a?.b.c` (`c` is the end of the chain starting at `a?.` since parens end the chain)
+ * 4. For `a?.b.c?.d`, both `a?.b.c` and `a?.b.c?.d` are outermost (`c` is the end of the chain starting at `a?.`, and `d` is
+ *   the end of the chain starting at `c?.`)
+ * 5. For `a?.(b?.c).d`, both `b?.c` and `a?.(b?.c)d` are outermost (`c` is the end of the chain starting at `b`, and `d` is
+ *   the end of the chain starting at `a?.`)
+ */
+export function isOutermostOptionalChain(node) {
+    return !isOptionalChain(node.parent) // cases 1, 2, and 3
+        || isOptionalChainRoot(node.parent) // case 4
+        || node !== node.parent.expression; // case 5
+}
+export function isNullishCoalesce(node) {
+    return node.kind === 209 /* SyntaxKind.BinaryExpression */ && node.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */;
+}
+export function isParenthesizedExpression(node) {
+    return node.kind === 200 /* SyntaxKind.ParenthesizedExpression */;
+}
+export function skipPartiallyEmittedExpressions(node) {
+    return skipOuterExpressions(node, 8 /* OuterExpressionKinds.PartiallyEmittedExpressions */);
+}
+export function isArrowFunction(node) {
+    return node.kind === 202 /* SyntaxKind.ArrowFunction */;
+}
+export function isDeleteExpression(node) {
+    return node.kind === 203 /* SyntaxKind.DeleteExpression */;
+}
+export function isTypeOfExpression(node) {
+    return node.kind === 204 /* SyntaxKind.TypeOfExpression */;
+}
+export function isAwaitExpression(node) {
+    return node.kind === 206 /* SyntaxKind.AwaitExpression */;
+}
+export function isPrefixUnaryExpression(node) {
+    return node.kind === 207 /* SyntaxKind.PrefixUnaryExpression */;
+}
+export function isBinaryExpression(node) {
+    return node.kind === 209 /* SyntaxKind.BinaryExpression */;
+}
+export function isSpreadElement(node) {
+    return node.kind === 213 /* SyntaxKind.SpreadElement */;
+}
+export function isOmittedExpression(node) {
+    return node.kind === 215 /* SyntaxKind.OmittedExpression */;
+}
+export function isAsExpression(node) {
+    return node.kind === 217 /* SyntaxKind.AsExpression */;
+}
+export function isMetaProperty(node) {
+    return node.kind === 219 /* SyntaxKind.MetaProperty */;
+}
+// Misc
+export function isTemplateSpan(node) {
+    return node.kind === 221 /* SyntaxKind.TemplateSpan */;
+}
+// Block
+export function isBlock(node) {
+    return node.kind === 223 /* SyntaxKind.Block */;
+}
+export function isVariableStatement(node) {
+    return node.kind === 225 /* SyntaxKind.VariableStatement */;
+}
+export function isEmptyStatement(node) {
+    return node.kind === 224 /* SyntaxKind.EmptyStatement */;
+}
+export function isExpressionStatement(node) {
+    return node.kind === 226 /* SyntaxKind.ExpressionStatement */;
+}
+export function isIfStatement(node) {
+    return node.kind === 227 /* SyntaxKind.IfStatement */;
+}
+export function isForInStatement(node) {
+    return node.kind === 231 /* SyntaxKind.ForInStatement */;
+}
+export function isForOfStatement(node) {
+    return node.kind === 232 /* SyntaxKind.ForOfStatement */;
+}
+export function isBreakOrContinueStatement(node) {
+    return node.kind === 234 /* SyntaxKind.BreakStatement */ || node.kind === 233 /* SyntaxKind.ContinueStatement */;
+}
+export function isReturnStatement(node) {
+    return node.kind === 235 /* SyntaxKind.ReturnStatement */;
+}
+export function isSwitchStatement(node) {
+    return node.kind === 237 /* SyntaxKind.SwitchStatement */;
+}
+export function isThrowStatement(node) {
+    return node.kind === 239 /* SyntaxKind.ThrowStatement */;
+}
+export function isTryStatement(node) {
+    return node.kind === 240 /* SyntaxKind.TryStatement */;
+}
+export function isVariableDeclaration(node) {
+    return node.kind === 242 /* SyntaxKind.VariableDeclaration */;
+}
+export function isVariableDeclarationList(node) {
+    return node.kind === 243 /* SyntaxKind.VariableDeclarationList */;
+}
+export function isTypeAliasDeclaration(node) {
+    return node.kind === 247 /* SyntaxKind.TypeAliasDeclaration */;
+}
+export function isModuleDeclaration(node) {
+    return node.kind === 249 /* SyntaxKind.ModuleDeclaration */;
+}
+export function isModuleBlock(node) {
+    return node.kind === 250 /* SyntaxKind.ModuleBlock */;
+}
+export function isCaseBlock(node) {
+    return node.kind === 251 /* SyntaxKind.CaseBlock */;
+}
+export function isImportDeclaration(node) {
+    return node.kind === 254 /* SyntaxKind.ImportDeclaration */;
+}
+export function isImportClause(node) {
+    return node.kind === 255 /* SyntaxKind.ImportClause */;
+}
+export function isNamespaceImport(node) {
+    return node.kind === 256 /* SyntaxKind.NamespaceImport */;
+}
+export function isNamespaceExport(node) {
+    return node.kind === 262 /* SyntaxKind.NamespaceExport */;
+}
+export function isNamedExportBindings(node) {
+    return node.kind === 262 /* SyntaxKind.NamespaceExport */ || node.kind === 261 /* SyntaxKind.NamedExports */;
+}
+export function isNamedImports(node) {
+    return node.kind === 257 /* SyntaxKind.NamedImports */;
+}
+export function isImportSpecifier(node) {
+    return node.kind === 258 /* SyntaxKind.ImportSpecifier */;
+}
+export function isExportAssignment(node) {
+    return node.kind === 259 /* SyntaxKind.ExportAssignment */;
+}
+export function isExportDeclaration(node) {
+    return node.kind === 260 /* SyntaxKind.ExportDeclaration */;
+}
+export function isNamedExports(node) {
+    return node.kind === 261 /* SyntaxKind.NamedExports */;
+}
+export function isExportSpecifier(node) {
+    return node.kind === 263 /* SyntaxKind.ExportSpecifier */;
+}
+// JSX
+export function isJsxElement(node) {
+    return node.kind === 266 /* SyntaxKind.JsxElement */;
+}
+export function isJsxSelfClosingElement(node) {
+    return node.kind === 267 /* SyntaxKind.JsxSelfClosingElement */;
+}
+export function isJsxOpeningElement(node) {
+    return node.kind === 268 /* SyntaxKind.JsxOpeningElement */;
+}
+export function isJsxClosingElement(node) {
+    return node.kind === 269 /* SyntaxKind.JsxClosingElement */;
+}
+export function isJsxOpeningFragment(node) {
+    return node.kind === 271 /* SyntaxKind.JsxOpeningFragment */;
+}
+export function isJsxClosingFragment(node) {
+    return node.kind === 272 /* SyntaxKind.JsxClosingFragment */;
+}
+export function isJsxAttribute(node) {
+    return node.kind === 273 /* SyntaxKind.JsxAttribute */;
+}
+export function isJsxAttributes(node) {
+    return node.kind === 274 /* SyntaxKind.JsxAttributes */;
+}
+export function isJsxSpreadAttribute(node) {
+    return node.kind === 275 /* SyntaxKind.JsxSpreadAttribute */;
+}
+export function isJsxExpression(node) {
+    return node.kind === 276 /* SyntaxKind.JsxExpression */;
+}
+// Clauses
+export function isCaseClause(node) {
+    return node.kind === 277 /* SyntaxKind.CaseClause */;
+}
+export function isDefaultClause(node) {
+    return node.kind === 278 /* SyntaxKind.DefaultClause */;
+}
+export function isCatchClause(node) {
+    return node.kind === 280 /* SyntaxKind.CatchClause */;
+}
+// Property assignments
+export function isPropertyAssignment(node) {
+    return node.kind === 281 /* SyntaxKind.PropertyAssignment */;
+}
+export function isShorthandPropertyAssignment(node) {
+    return node.kind === 282 /* SyntaxKind.ShorthandPropertyAssignment */;
+}
+export function isSpreadAssignment(node) {
+    return node.kind === 283 /* SyntaxKind.SpreadAssignment */;
+}
+// Top-level nodes
+export function isSourceFile(node) {
+    return node.kind === 290 /* SyntaxKind.SourceFile */;
+}
+export function isUnparsedSource(node) {
+    return node.kind === 292 /* SyntaxKind.UnparsedSource */;
+}
+export function isUnparsedPrepend(node) {
+    return node.kind === 286 /* SyntaxKind.UnparsedPrepend */;
+}
+export function isUnparsedTextLike(node) {
+    switch (node.kind) {
+        case 287 /* SyntaxKind.UnparsedText */:
+        case 288 /* SyntaxKind.UnparsedInternalText */:
+            return true;
+        default:
+            return false;
+    }
+}
+export function isUnparsedNode(node) {
+    return isUnparsedTextLike(node) ||
+        node.kind === 285 /* SyntaxKind.UnparsedPrologue */ ||
+        node.kind === 289 /* SyntaxKind.UnparsedSyntheticReference */;
+}
+// #endregion
+// #region
+// Node tests
+//
+// All node tests in the following list should *not* reference parent pointers so that
+// they may be used with transformations.
+export function isSyntaxList(n) {
+    return n.kind === 324 /* SyntaxKind.SyntaxList */;
+}
+export function isNodeKind(kind) {
+    return kind >= 153 /* SyntaxKind.FirstNode */;
+}
+/**
+ * True if node is of some token syntax kind.
+ * For example, this is true for an IfKeyword but not for an IfStatement.
+ * Literals are considered tokens, except TemplateLiteral, but does include TemplateHead/Middle/Tail.
+ */
+export function isToken(n) {
+    return n.kind >= 0 /* SyntaxKind.FirstToken */ && n.kind <= 152 /* SyntaxKind.LastToken */;
+}
+// Node Arrays
+export function isNodeArray(array) {
+    return array.hasOwnProperty("pos") && array.hasOwnProperty("end");
+}
+// Literals
+export function isLiteralKind(kind) {
+    return 8 /* SyntaxKind.FirstLiteralToken */ <= kind && kind <= 14 /* SyntaxKind.LastLiteralToken */;
+}
+export function isLiteralExpression(node) {
+    return isLiteralKind(node.kind);
+}
+// Pseudo-literals
+export function isTemplateLiteralKind(kind) {
+    return 14 /* SyntaxKind.FirstTemplateToken */ <= kind && kind <= 17 /* SyntaxKind.LastTemplateToken */;
+}
+export function isTemplateMiddleOrTemplateTail(node) {
+    const kind = node.kind;
+    return kind === 16 /* SyntaxKind.TemplateMiddle */
+        || kind === 17 /* SyntaxKind.TemplateTail */;
+}
+export function isImportOrExportSpecifier(node) {
+    return isImportSpecifier(node) || isExportSpecifier(node);
+}
+export function isTypeOnlyImportOrExportDeclaration(node) {
+    switch (node.kind) {
+        case 258 /* SyntaxKind.ImportSpecifier */:
+        case 263 /* SyntaxKind.ExportSpecifier */:
+            return node.parent.parent.isTypeOnly;
+        case 256 /* SyntaxKind.NamespaceImport */:
+            return node.parent.isTypeOnly;
+        case 255 /* SyntaxKind.ImportClause */:
+            return node.isTypeOnly;
+        default:
+            return false;
+    }
+}
+export function isStringTextContainingNode(node) {
+    return node.kind === 10 /* SyntaxKind.StringLiteral */ || isTemplateLiteralKind(node.kind);
+}
+// Identifiers
+export function isGeneratedIdentifier(node) {
+    return isIdentifier(node) && (node.autoGenerateFlags & 7 /* GeneratedIdentifierFlags.KindMask */) > 0 /* GeneratedIdentifierFlags.None */;
+}
+// Keywords
+export function isModifierKind(token) {
+    switch (token) {
+        case 126 /* SyntaxKind.AsyncKeyword */:
+        case 130 /* SyntaxKind.DeclareKeyword */:
+        case 89 /* SyntaxKind.ExportKeyword */:
+        case 138 /* SyntaxKind.ReadonlyKeyword */:
+            return true;
+    }
+    return false;
+}
+export function isModifier(node) {
+    return isModifierKind(node.kind);
+}
+export function isEntityName(node) {
+    const kind = node.kind;
+    return kind === 153 /* SyntaxKind.QualifiedName */
+        || kind === 75 /* SyntaxKind.Identifier */;
+}
+export function isPropertyName(node) {
+    const kind = node.kind;
+    return kind === 75 /* SyntaxKind.Identifier */
+        || kind === 10 /* SyntaxKind.StringLiteral */
+        || kind === 8 /* SyntaxKind.NumericLiteral */
+        || kind === 154 /* SyntaxKind.ComputedPropertyName */;
+}
+export function isBindingName(node) {
+    const kind = node.kind;
+    return kind === 75 /* SyntaxKind.Identifier */
+        || kind === 189 /* SyntaxKind.ObjectBindingPattern */
+        || kind === 190 /* SyntaxKind.ArrayBindingPattern */;
+}
+// Functions
+export function isFunctionLike(node) {
+    return node && isFunctionLikeKind(node.kind);
+}
+export function isFunctionLikeDeclaration(node) {
+    return node && isFunctionLikeDeclarationKind(node.kind);
+}
+function isFunctionLikeDeclarationKind(kind) {
+    switch (kind) {
+        case 202 /* SyntaxKind.ArrowFunction */:
+            return true;
+        default:
+            return false;
+    }
+}
+export function isFunctionLikeKind(kind) {
+    switch (kind) {
+        case 160 /* SyntaxKind.MethodSignature */:
+        case 165 /* SyntaxKind.CallSignature */:
+        case 167 /* SyntaxKind.IndexSignature */:
+        case 170 /* SyntaxKind.FunctionType */:
+            return true;
+        default:
+            return isFunctionLikeDeclarationKind(kind);
+    }
+}
+export function isFunctionOrModuleBlock(node) {
+    return isSourceFile(node) || isModuleBlock(node) || isBlock(node) && isFunctionLike(node.parent);
+}
+// Type members
+export function isTypeElement(node) {
+    const kind = node.kind;
+    return kind === 165 /* SyntaxKind.CallSignature */
+        || kind === 158 /* SyntaxKind.PropertySignature */
+        || kind === 160 /* SyntaxKind.MethodSignature */
+        || kind === 167 /* SyntaxKind.IndexSignature */;
+}
+export function isObjectLiteralElementLike(node) {
+    const kind = node.kind;
+    return kind === 281 /* SyntaxKind.PropertyAssignment */
+        || kind === 282 /* SyntaxKind.ShorthandPropertyAssignment */
+        || kind === 283 /* SyntaxKind.SpreadAssignment */;
+}
+// Type
+/**
+ * Node test that determines whether a node is a valid type node.
+ * This differs from the `isPartOfTypeNode` function which determines whether a node is *part*
+ * of a TypeNode.
+ */
+export function isTypeNode(node) {
+    return isTypeNodeKind(node.kind);
+}
+// Binding patterns
+export function isBindingPattern(node) {
+    if (node) {
+        const kind = node.kind;
+        return kind === 190 /* SyntaxKind.ArrayBindingPattern */
+            || kind === 189 /* SyntaxKind.ObjectBindingPattern */;
+    }
+    return false;
+}
+export function isAssignmentPattern(node) {
+    const kind = node.kind;
+    return kind === 192 /* SyntaxKind.ArrayLiteralExpression */
+        || kind === 193 /* SyntaxKind.ObjectLiteralExpression */;
+}
+export function isArrayBindingElement(node) {
+    const kind = node.kind;
+    return kind === 191 /* SyntaxKind.BindingElement */
+        || kind === 215 /* SyntaxKind.OmittedExpression */;
+}
+/**
+ * Determines whether the BindingOrAssignmentElement is a BindingElement-like declaration
+ */
+export function isDeclarationBindingElement(bindingElement) {
+    switch (bindingElement.kind) {
+        case 242 /* SyntaxKind.VariableDeclaration */:
+        case 156 /* SyntaxKind.Parameter */:
+        case 191 /* SyntaxKind.BindingElement */:
+            return true;
+    }
+    return false;
+}
+export function isPropertyAccessOrQualifiedNameOrImportTypeNode(node) {
+    const kind = node.kind;
+    return kind === 194 /* SyntaxKind.PropertyAccessExpression */
+        || kind === 153 /* SyntaxKind.QualifiedName */
+        || kind === 188 /* SyntaxKind.ImportType */;
+}
+// Expression
+export function isPropertyAccessOrQualifiedName(node) {
+    const kind = node.kind;
+    return kind === 194 /* SyntaxKind.PropertyAccessExpression */
+        || kind === 153 /* SyntaxKind.QualifiedName */;
+}
+export function isCallLikeExpression(node) {
+    switch (node.kind) {
+        case 268 /* SyntaxKind.JsxOpeningElement */:
+        case 267 /* SyntaxKind.JsxSelfClosingElement */:
+        case 196 /* SyntaxKind.CallExpression */:
+            return true;
+        default:
+            return false;
+    }
+}
+/** A chamada. Na tag, também o `new` (CK-02). */
+export function isCallOrNewExpression(node) {
+    return node.kind === 196 /* SyntaxKind.CallExpression */;
+}
+export function isTemplateLiteral(node) {
+    const kind = node.kind;
+    return kind === 211 /* SyntaxKind.TemplateExpression */
+        || kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */;
+}
+export function isLeftHandSideExpression(node) {
+    return isLeftHandSideExpressionKind(skipPartiallyEmittedExpressions(node).kind);
+}
+function isLeftHandSideExpressionKind(kind) {
+    switch (kind) {
+        case 194 /* SyntaxKind.PropertyAccessExpression */:
+        case 195 /* SyntaxKind.ElementAccessExpression */:
+        case 196 /* SyntaxKind.CallExpression */:
+        case 266 /* SyntaxKind.JsxElement */:
+        case 267 /* SyntaxKind.JsxSelfClosingElement */:
+        case 270 /* SyntaxKind.JsxFragment */:
+        case 192 /* SyntaxKind.ArrayLiteralExpression */:
+        case 200 /* SyntaxKind.ParenthesizedExpression */:
+        case 193 /* SyntaxKind.ObjectLiteralExpression */:
+        case 75 /* SyntaxKind.Identifier */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 211 /* SyntaxKind.TemplateExpression */:
+        case 91 /* SyntaxKind.FalseKeyword */:
+        case 100 /* SyntaxKind.NullKeyword */:
+        case 106 /* SyntaxKind.TrueKeyword */:
+        case 219 /* SyntaxKind.MetaProperty */:
+        case 96 /* SyntaxKind.ImportKeyword */: // technically this is only an Expression if it's in a CallExpression
+            return true;
+        default:
+            return false;
+    }
+}
+export function isUnaryExpression(node) {
+    return isUnaryExpressionKind(skipPartiallyEmittedExpressions(node).kind);
+}
+function isUnaryExpressionKind(kind) {
+    switch (kind) {
+        case 207 /* SyntaxKind.PrefixUnaryExpression */:
+        case 208 /* SyntaxKind.PostfixUnaryExpression */:
+        case 203 /* SyntaxKind.DeleteExpression */:
+        case 204 /* SyntaxKind.TypeOfExpression */:
+        case 206 /* SyntaxKind.AwaitExpression */:
+            return true;
+        default:
+            return isLeftHandSideExpressionKind(kind);
+    }
+}
+export function isUnaryExpressionWithWrite(expr) {
+    switch (expr.kind) {
+        case 208 /* SyntaxKind.PostfixUnaryExpression */:
+            return true;
+        case 207 /* SyntaxKind.PrefixUnaryExpression */:
+            return expr.operator === 45 /* SyntaxKind.PlusPlusToken */ ||
+                expr.operator === 46 /* SyntaxKind.MinusMinusToken */;
+        default:
+            return false;
+    }
+}
+/**
+ * Determines whether a node is an expression based only on its kind.
+ * Use `isExpressionNode` if not in transforms.
+ */
+export function isExpression(node) {
+    return isExpressionKind(skipPartiallyEmittedExpressions(node).kind);
+}
+function isExpressionKind(kind) {
+    switch (kind) {
+        case 210 /* SyntaxKind.ConditionalExpression */:
+        case 202 /* SyntaxKind.ArrowFunction */:
+        case 209 /* SyntaxKind.BinaryExpression */:
+        case 213 /* SyntaxKind.SpreadElement */:
+        case 217 /* SyntaxKind.AsExpression */:
+        case 215 /* SyntaxKind.OmittedExpression */:
+        case 327 /* SyntaxKind.CommaListExpression */:
+        case 326 /* SyntaxKind.PartiallyEmittedExpression */:
+            return true;
+        default:
+            return isUnaryExpressionKind(kind);
+    }
+}
+export function isAssertionExpression(node) {
+    const kind = node.kind;
+    return kind === 217 /* SyntaxKind.AsExpression */;
+}
+export function isNotEmittedStatement(node) {
+    return node.kind === 325 /* SyntaxKind.NotEmittedStatement */;
+}
+// Statement
+export function isIterationStatement(node) {
+    switch (node.kind) {
+        case 230 /* SyntaxKind.ForStatement */:
+        case 231 /* SyntaxKind.ForInStatement */:
+        case 232 /* SyntaxKind.ForOfStatement */:
+        case 228 /* SyntaxKind.DoStatement */:
+        case 229 /* SyntaxKind.WhileStatement */:
+            return true;
+    }
+    return false;
+}
+export function isForInOrOfStatement(node) {
+    return node.kind === 231 /* SyntaxKind.ForInStatement */ || node.kind === 232 /* SyntaxKind.ForOfStatement */;
+}
+// Element
+export function isConciseBody(node) {
+    return isBlock(node)
+        || isExpression(node);
+}
+export function isForInitializer(node) {
+    return isVariableDeclarationList(node)
+        || isExpression(node);
+}
+export function isModuleBody(node) {
+    const kind = node.kind;
+    return kind === 250 /* SyntaxKind.ModuleBlock */
+        || kind === 249 /* SyntaxKind.ModuleDeclaration */
+        || kind === 75 /* SyntaxKind.Identifier */;
+}
+export function isNamedImportBindings(node) {
+    const kind = node.kind;
+    return kind === 257 /* SyntaxKind.NamedImports */
+        || kind === 256 /* SyntaxKind.NamespaceImport */;
+}
+function isDeclarationKind(kind) {
+    return kind === 202 /* SyntaxKind.ArrowFunction */
+        || kind === 191 /* SyntaxKind.BindingElement */
+        || kind === 263 /* SyntaxKind.ExportSpecifier */
+        || kind === 255 /* SyntaxKind.ImportClause */
+        || kind === 258 /* SyntaxKind.ImportSpecifier */
+        || kind === 273 /* SyntaxKind.JsxAttribute */
+        || kind === 249 /* SyntaxKind.ModuleDeclaration */
+        || kind === 256 /* SyntaxKind.NamespaceImport */
+        || kind === 262 /* SyntaxKind.NamespaceExport */
+        || kind === 156 /* SyntaxKind.Parameter */
+        || kind === 281 /* SyntaxKind.PropertyAssignment */
+        || kind === 158 /* SyntaxKind.PropertySignature */
+        || kind === 282 /* SyntaxKind.ShorthandPropertyAssignment */
+        || kind === 247 /* SyntaxKind.TypeAliasDeclaration */
+        || kind === 155 /* SyntaxKind.TypeParameter */
+        || kind === 242 /* SyntaxKind.VariableDeclaration */;
+}
+function isDeclarationStatementKind(kind) {
+    return kind === 264 /* SyntaxKind.MissingDeclaration */
+        || kind === 247 /* SyntaxKind.TypeAliasDeclaration */
+        || kind === 249 /* SyntaxKind.ModuleDeclaration */
+        || kind === 254 /* SyntaxKind.ImportDeclaration */
+        || kind === 260 /* SyntaxKind.ExportDeclaration */
+        || kind === 259 /* SyntaxKind.ExportAssignment */;
+}
+function isStatementKindButNotDeclarationKind(kind) {
+    return kind === 234 /* SyntaxKind.BreakStatement */
+        || kind === 233 /* SyntaxKind.ContinueStatement */
+        || kind === 228 /* SyntaxKind.DoStatement */
+        || kind === 226 /* SyntaxKind.ExpressionStatement */
+        || kind === 224 /* SyntaxKind.EmptyStatement */
+        || kind === 231 /* SyntaxKind.ForInStatement */
+        || kind === 232 /* SyntaxKind.ForOfStatement */
+        || kind === 230 /* SyntaxKind.ForStatement */
+        || kind === 227 /* SyntaxKind.IfStatement */
+        || kind === 235 /* SyntaxKind.ReturnStatement */
+        || kind === 237 /* SyntaxKind.SwitchStatement */
+        || kind === 239 /* SyntaxKind.ThrowStatement */
+        || kind === 240 /* SyntaxKind.TryStatement */
+        || kind === 225 /* SyntaxKind.VariableStatement */
+        || kind === 229 /* SyntaxKind.WhileStatement */
+        || kind === 325 /* SyntaxKind.NotEmittedStatement */
+        || kind === 329 /* SyntaxKind.EndOfDeclarationMarker */
+        || kind === 328 /* SyntaxKind.MergeDeclarationMarker */;
+}
+export function isDeclaration(node) {
+    if (node.kind === 155 /* SyntaxKind.TypeParameter */) {
+        return !!node.parent;
+    }
+    return isDeclarationKind(node.kind);
+}
+/**
+ * Determines whether the node is a statement that is not also a declaration
+ */
+export function isStatementButNotDeclaration(node) {
+    return isStatementKindButNotDeclarationKind(node.kind);
+}
+export function isStatement(node) {
+    const kind = node.kind;
+    return isStatementKindButNotDeclarationKind(kind)
+        || isDeclarationStatementKind(kind)
+        || isBlockStatement(node);
+}
+function isBlockStatement(node) {
+    if (node.kind !== 223 /* SyntaxKind.Block */)
+        return false;
+    if (node.parent !== undefined) {
+        if (node.parent.kind === 240 /* SyntaxKind.TryStatement */ || node.parent.kind === 280 /* SyntaxKind.CatchClause */) {
+            return false;
+        }
+    }
+    return !isFunctionBlock(node);
+}
+// JSX
+export function isJsxTagNameExpression(node) {
+    const kind = node.kind;
+    return kind === 75 /* SyntaxKind.Identifier */
+        || kind === 194 /* SyntaxKind.PropertyAccessExpression */;
+}
+export function isJsxChild(node) {
+    const kind = node.kind;
+    return kind === 266 /* SyntaxKind.JsxElement */
+        || kind === 276 /* SyntaxKind.JsxExpression */
+        || kind === 267 /* SyntaxKind.JsxSelfClosingElement */
+        || kind === 11 /* SyntaxKind.JsxText */
+        || kind === 270 /* SyntaxKind.JsxFragment */;
+}
+export function isJsxAttributeLike(node) {
+    const kind = node.kind;
+    return kind === 273 /* SyntaxKind.JsxAttribute */
+        || kind === 275 /* SyntaxKind.JsxSpreadAttribute */;
+}
+export function isStringLiteralOrJsxExpression(node) {
+    const kind = node.kind;
+    return kind === 10 /* SyntaxKind.StringLiteral */
+        || kind === 276 /* SyntaxKind.JsxExpression */;
+}
+export function isJsxOpeningLikeElement(node) {
+    const kind = node.kind;
+    return kind === 268 /* SyntaxKind.JsxOpeningElement */
+        || kind === 267 /* SyntaxKind.JsxSelfClosingElement */;
+}
+// Clauses
+export function isCaseOrDefaultClause(node) {
+    const kind = node.kind;
+    return kind === 277 /* SyntaxKind.CaseClause */
+        || kind === 278 /* SyntaxKind.DefaultClause */;
+}
+/** True if has type node attached to it. */
+export function hasType(node) {
+    return !!node.type;
+}
+/** True if has initializer node attached to it. */
+export function hasInitializer(node) {
+    return !!node.initializer;
+}
+export function isObjectLiteralElement(node) {
+    return node.kind === 273 /* SyntaxKind.JsxAttribute */ || node.kind === 275 /* SyntaxKind.JsxSpreadAttribute */ || isObjectLiteralElementLike(node);
+}
+export function isStringLiteralLike(node) {
+    return node.kind === 10 /* SyntaxKind.StringLiteral */ || node.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */;
+}
+// #endregion