tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/printer/utilities.js

@@ -0,0 +1,817 @@
+// Node predicates, literal text and line helpers shared by the printer and transforms.
+import { BigIntLiteral, BinaryExpression, CallExpression, ConditionalExpression, ElementAccessExpression, InferTypeNode, NewExpression, NoSubstitutionTemplateLiteral, NonNullExpression, NumericLiteral, ParenthesizedExpression, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PropertyAccessExpression, RegularExpressionLiteral, AsExpression, SatisfiesExpression, SourceFile, StringLiteral, TaggedTemplateExpression, TemplateHead, TemplateMiddle, TemplateTail, ExpressionStatement, Identifier, PrivateIdentifier, getExpression, } from '../ast.js';
+import { getBinaryOperatorPrecedence } from '../ast-utilities.js';
+import { isDigit, isLineBreak, isUnicodeWhiteSpace, isWhiteSpaceLike, isWhiteSpaceSingleLine, } from '../character-codes.js';
+import { computeLineOfPosition, skipTrivia } from '../scanner.js';
+import { getBaseFileName } from '../path.js';
+// Nodes
+export function positionIsSynthesized(pos) {
+    return pos < 0;
+}
+export function nodeIsSynthesized(node) {
+    return node.pos < 0 || node.end < 0;
+}
+/** Whether the parser (not a transform) created the node. */
+export function isParseTreeNode(node) {
+    return (node.flags & 16 /* NodeFlags.Synthesized */) === 0;
+}
+export function getSourceFileOfNode(node) {
+    while (node !== undefined) {
+        if (node instanceof SourceFile)
+            return node;
+        node = node.parent;
+    }
+    return undefined;
+}
+export function isPrologueDirective(node) {
+    return (node instanceof ExpressionStatement && node.expression.kind === 10 /* SyntaxKind.StringLiteral */);
+}
+export function isKeywordKind(kind) {
+    return kind >= 82 /* SyntaxKind.FirstKeyword */ && kind <= 166 /* SyntaxKind.LastKeyword */;
+}
+export function isPunctuationKind(kind) {
+    return kind >= 18 /* SyntaxKind.FirstPunctuation */ && kind <= 78 /* SyntaxKind.LastPunctuation */;
+}
+export function isLiteralKind(kind) {
+    return kind >= 8 /* SyntaxKind.FirstLiteralToken */ && kind <= 14 /* SyntaxKind.LastLiteralToken */;
+}
+export function isJSDocKind(kind) {
+    return kind >= 308 /* SyntaxKind.JSDocTypeExpression */ && kind <= 343 /* SyntaxKind.JSDocImportTag */;
+}
+export function isMemberName(node) {
+    return node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 80 /* SyntaxKind.PrivateIdentifier */;
+}
+export function isModifier(node) {
+    switch (node.kind) {
+        case 127 /* SyntaxKind.AbstractKeyword */:
+        case 128 /* SyntaxKind.AccessorKeyword */:
+        case 133 /* SyntaxKind.AsyncKeyword */:
+        case 86 /* SyntaxKind.ConstKeyword */:
+        case 137 /* SyntaxKind.DeclareKeyword */:
+        case 89 /* SyntaxKind.DefaultKeyword */:
+        case 94 /* SyntaxKind.ExportKeyword */:
+        case 102 /* SyntaxKind.InKeyword */:
+        case 122 /* SyntaxKind.PrivateKeyword */:
+        case 123 /* SyntaxKind.ProtectedKeyword */:
+        case 124 /* SyntaxKind.PublicKeyword */:
+        case 148 /* SyntaxKind.ReadonlyKeyword */:
+        case 147 /* SyntaxKind.OutKeyword */:
+        case 164 /* SyntaxKind.OverrideKeyword */:
+        case 125 /* SyntaxKind.StaticKeyword */:
+            return true;
+    }
+    return false;
+}
+export function isOptionalChain(node) {
+    if ((node.flags & 32 /* NodeFlags.OptionalChain */) === 0)
+        return false;
+    switch (node.kind) {
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 214 /* SyntaxKind.CallExpression */:
+        case 236 /* SyntaxKind.NonNullExpression */:
+            return true;
+    }
+    return false;
+}
+export function isUnterminatedLiteral(node) {
+    if (node instanceof StringLiteral)
+        return (node.tokenFlags & 4 /* TokenFlags.Unterminated */) !== 0;
+    if (node instanceof NumericLiteral)
+        return (node.tokenFlags & 4 /* TokenFlags.Unterminated */) !== 0;
+    if (node instanceof BigIntLiteral)
+        return (node.tokenFlags & 4 /* TokenFlags.Unterminated */) !== 0;
+    if (node instanceof RegularExpressionLiteral)
+        return (node.tokenFlags & 4 /* TokenFlags.Unterminated */) !== 0;
+    if (node instanceof NoSubstitutionTemplateLiteral)
+        return (node.templateFlags & 4 /* TokenFlags.Unterminated */) !== 0;
+    if (node instanceof TemplateHead)
+        return (node.templateFlags & 4 /* TokenFlags.Unterminated */) !== 0;
+    if (node instanceof TemplateMiddle)
+        return (node.templateFlags & 4 /* TokenFlags.Unterminated */) !== 0;
+    if (node instanceof TemplateTail)
+        return (node.templateFlags & 4 /* TokenFlags.Unterminated */) !== 0;
+    return false;
+}
+export function skipPartiallyEmittedExpressions(node) {
+    while (node instanceof PartiallyEmittedExpression)
+        node = node.expression;
+    return node;
+}
+/** Whether a variable declaration list declares `let`, `const`, `using` or `await using`, as `NodeFlags.BlockScoped`. */
+export function blockScopeFlags(node) {
+    let flags = node.flags;
+    const parent = node.parent;
+    if (parent !== undefined && parent.kind === 244 /* SyntaxKind.VariableStatement */)
+        flags |= parent.flags;
+    return flags & 7 /* NodeFlags.BlockScoped */;
+}
+function isLeftHandSideExpressionKind(kind) {
+    switch (kind) {
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 215 /* SyntaxKind.NewExpression */:
+        case 214 /* SyntaxKind.CallExpression */:
+        case 285 /* SyntaxKind.JsxElement */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 289 /* SyntaxKind.JsxFragment */:
+        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 232 /* SyntaxKind.ClassExpression */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 79 /* SyntaxKind.Identifier */:
+        case 80 /* SyntaxKind.PrivateIdentifier */:
+        case 13 /* SyntaxKind.RegularExpressionLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 229 /* SyntaxKind.TemplateExpression */:
+        case 96 /* SyntaxKind.FalseKeyword */:
+        case 105 /* SyntaxKind.NullKeyword */:
+        case 109 /* SyntaxKind.ThisKeyword */:
+        case 111 /* SyntaxKind.TrueKeyword */:
+        case 107 /* SyntaxKind.SuperKeyword */:
+        case 236 /* SyntaxKind.NonNullExpression */:
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 237 /* SyntaxKind.MetaProperty */:
+        case 101 /* SyntaxKind.ImportKeyword */:
+        case 283 /* SyntaxKind.MissingDeclaration */:
+            return true;
+    }
+    return false;
+}
+function isUnaryExpressionKind(kind) {
+    switch (kind) {
+        case 225 /* SyntaxKind.PrefixUnaryExpression */:
+        case 226 /* SyntaxKind.PostfixUnaryExpression */:
+        case 221 /* SyntaxKind.DeleteExpression */:
+        case 222 /* SyntaxKind.TypeOfExpression */:
+        case 223 /* SyntaxKind.VoidExpression */:
+        case 224 /* SyntaxKind.AwaitExpression */:
+        case 217 /* SyntaxKind.TypeAssertionExpression */:
+            return true;
+    }
+    return isLeftHandSideExpressionKind(kind);
+}
+export function isExpressionKind(kind) {
+    switch (kind) {
+        case 228 /* SyntaxKind.ConditionalExpression */:
+        case 230 /* SyntaxKind.YieldExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+        case 227 /* SyntaxKind.BinaryExpression */:
+        case 231 /* SyntaxKind.SpreadElement */:
+        case 235 /* SyntaxKind.AsExpression */:
+        case 233 /* SyntaxKind.OmittedExpression */:
+        case 348 /* SyntaxKind.PartiallyEmittedExpression */:
+        case 239 /* SyntaxKind.SatisfiesExpression */:
+            return true;
+    }
+    return isUnaryExpressionKind(kind);
+}
+export function isExpression(node) {
+    return isExpressionKind(skipPartiallyEmittedExpressions(node).kind);
+}
+export function isTypeNodeKind(kind) {
+    switch (kind) {
+        case 132 /* SyntaxKind.AnyKeyword */:
+        case 159 /* SyntaxKind.UnknownKeyword */:
+        case 150 /* SyntaxKind.NumberKeyword */:
+        case 163 /* SyntaxKind.BigIntKeyword */:
+        case 151 /* SyntaxKind.ObjectKeyword */:
+        case 135 /* SyntaxKind.BooleanKeyword */:
+        case 154 /* SyntaxKind.StringKeyword */:
+        case 155 /* SyntaxKind.SymbolKeyword */:
+        case 115 /* SyntaxKind.VoidKeyword */:
+        case 157 /* SyntaxKind.UndefinedKeyword */:
+        case 146 /* SyntaxKind.NeverKeyword */:
+        case 141 /* SyntaxKind.IntrinsicKeyword */:
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 310 /* SyntaxKind.JSDocAllType */:
+        case 311 /* SyntaxKind.JSDocNullableType */:
+        case 312 /* SyntaxKind.JSDocNonNullableType */:
+        case 313 /* SyntaxKind.JSDocOptionalType */:
+        case 314 /* SyntaxKind.JSDocVariadicType */:
+            return true;
+    }
+    return kind >= 183 /* SyntaxKind.FirstTypeNode */ && kind <= 206 /* SyntaxKind.LastTypeNode */;
+}
+function isDeclarationStatementKind(kind) {
+    switch (kind) {
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 283 /* SyntaxKind.MissingDeclaration */:
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 267 /* SyntaxKind.EnumDeclaration */:
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 273 /* SyntaxKind.ImportDeclaration */:
+        case 346 /* SyntaxKind.JSImportDeclaration */:
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 279 /* SyntaxKind.ExportDeclaration */:
+        case 278 /* SyntaxKind.ExportAssignment */:
+        case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+            return true;
+    }
+    return false;
+}
+function isStatementKindButNotDeclarationKind(kind) {
+    switch (kind) {
+        case 253 /* SyntaxKind.BreakStatement */:
+        case 252 /* SyntaxKind.ContinueStatement */:
+        case 260 /* SyntaxKind.DebuggerStatement */:
+        case 247 /* SyntaxKind.DoStatement */:
+        case 245 /* SyntaxKind.ExpressionStatement */:
+        case 243 /* SyntaxKind.EmptyStatement */:
+        case 250 /* SyntaxKind.ForInStatement */:
+        case 251 /* SyntaxKind.ForOfStatement */:
+        case 249 /* SyntaxKind.ForStatement */:
+        case 246 /* SyntaxKind.IfStatement */:
+        case 257 /* SyntaxKind.LabeledStatement */:
+        case 254 /* SyntaxKind.ReturnStatement */:
+        case 256 /* SyntaxKind.SwitchStatement */:
+        case 258 /* SyntaxKind.ThrowStatement */:
+        case 259 /* SyntaxKind.TryStatement */:
+        case 244 /* SyntaxKind.VariableStatement */:
+        case 248 /* SyntaxKind.WhileStatement */:
+        case 255 /* SyntaxKind.WithStatement */:
+        case 347 /* SyntaxKind.NotEmittedStatement */:
+            return true;
+    }
+    return false;
+}
+export function isFunctionLikeKind(kind) {
+    switch (kind) {
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 177 /* SyntaxKind.Constructor */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+        case 174 /* SyntaxKind.MethodSignature */:
+        case 180 /* SyntaxKind.CallSignature */:
+        case 318 /* SyntaxKind.JSDocSignature */:
+        case 181 /* SyntaxKind.ConstructSignature */:
+        case 182 /* SyntaxKind.IndexSignature */:
+        case 185 /* SyntaxKind.FunctionType */:
+        case 186 /* SyntaxKind.ConstructorType */:
+            return true;
+    }
+    return false;
+}
+export function isStatement(node) {
+    const kind = node.kind;
+    if (isStatementKindButNotDeclarationKind(kind) || isDeclarationStatementKind(kind))
+        return true;
+    if (kind !== 242 /* SyntaxKind.Block */)
+        return false;
+    const parent = node.parent;
+    if (parent === undefined)
+        return true;
+    return (parent.kind !== 259 /* SyntaxKind.TryStatement */ &&
+        parent.kind !== 300 /* SyntaxKind.CatchClause */ &&
+        !isFunctionLikeKind(parent.kind));
+}
+// Precedence
+export function getExpressionPrecedence(expression) {
+    switch (expression.kind) {
+        case 231 /* SyntaxKind.SpreadElement */:
+            return 1 /* OperatorPrecedence.Spread */;
+        case 230 /* SyntaxKind.YieldExpression */:
+            return 2 /* OperatorPrecedence.Yield */;
+        case 220 /* SyntaxKind.ArrowFunction */:
+            return 3 /* OperatorPrecedence.Assignment */;
+        case 228 /* SyntaxKind.ConditionalExpression */:
+            return 4 /* OperatorPrecedence.Conditional */;
+        case 227 /* SyntaxKind.BinaryExpression */:
+            if (expression instanceof BinaryExpression) {
+                const operator = expression.operatorToken.kind;
+                if (operator === 27 /* SyntaxKind.CommaToken */)
+                    return 0 /* OperatorPrecedence.Comma */;
+                if (operator >= 63 /* SyntaxKind.FirstAssignment */ && operator <= 78 /* SyntaxKind.LastAssignment */)
+                    return 3 /* OperatorPrecedence.Assignment */;
+                return getBinaryOperatorPrecedence(operator);
+            }
+            return -1 /* OperatorPrecedence.Invalid */;
+        case 217 /* SyntaxKind.TypeAssertionExpression */:
+        case 236 /* SyntaxKind.NonNullExpression */:
+        case 225 /* SyntaxKind.PrefixUnaryExpression */:
+        case 222 /* SyntaxKind.TypeOfExpression */:
+        case 223 /* SyntaxKind.VoidExpression */:
+        case 221 /* SyntaxKind.DeleteExpression */:
+        case 224 /* SyntaxKind.AwaitExpression */:
+            return 16 /* OperatorPrecedence.Unary */;
+        case 226 /* SyntaxKind.PostfixUnaryExpression */:
+            return 17 /* OperatorPrecedence.Update */;
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 214 /* SyntaxKind.CallExpression */:
+            return isOptionalChain(expression) ? 19 /* OperatorPrecedence.OptionalChain */ : 20 /* OperatorPrecedence.Member */;
+        case 215 /* SyntaxKind.NewExpression */:
+            return expression instanceof NewExpression && expression.arguments === undefined
+                ? 18 /* OperatorPrecedence.LeftHandSide */
+                : 20 /* OperatorPrecedence.Member */;
+        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+        case 237 /* SyntaxKind.MetaProperty */:
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            return 20 /* OperatorPrecedence.Member */;
+        case 235 /* SyntaxKind.AsExpression */:
+        case 239 /* SyntaxKind.SatisfiesExpression */:
+            return 11 /* OperatorPrecedence.Relational */;
+        case 109 /* SyntaxKind.ThisKeyword */:
+        case 107 /* SyntaxKind.SuperKeyword */:
+        case 101 /* SyntaxKind.ImportKeyword */:
+        case 79 /* SyntaxKind.Identifier */:
+        case 80 /* SyntaxKind.PrivateIdentifier */:
+        case 105 /* SyntaxKind.NullKeyword */:
+        case 111 /* SyntaxKind.TrueKeyword */:
+        case 96 /* SyntaxKind.FalseKeyword */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 232 /* SyntaxKind.ClassExpression */:
+        case 13 /* SyntaxKind.RegularExpressionLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 229 /* SyntaxKind.TemplateExpression */:
+        case 233 /* SyntaxKind.OmittedExpression */:
+        case 285 /* SyntaxKind.JsxElement */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 289 /* SyntaxKind.JsxFragment */:
+        case 283 /* SyntaxKind.MissingDeclaration */:
+            return 21 /* OperatorPrecedence.Primary */;
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+            return 22 /* OperatorPrecedence.Parentheses */;
+    }
+    return -1 /* OperatorPrecedence.Invalid */;
+}
+export function getTypeNodePrecedence(node) {
+    switch (node.kind) {
+        case 195 /* SyntaxKind.ConditionalType */:
+            return 0 /* TypePrecedence.Conditional */;
+        case 313 /* SyntaxKind.JSDocOptionalType */:
+        case 314 /* SyntaxKind.JSDocVariadicType */:
+            return 1 /* TypePrecedence.JSDoc */;
+        case 185 /* SyntaxKind.FunctionType */:
+        case 186 /* SyntaxKind.ConstructorType */:
+            return 2 /* TypePrecedence.Function */;
+        case 193 /* SyntaxKind.UnionType */:
+            return 3 /* TypePrecedence.Union */;
+        case 194 /* SyntaxKind.IntersectionType */:
+            return 4 /* TypePrecedence.Intersection */;
+        case 199 /* SyntaxKind.TypeOperator */:
+        case 187 /* SyntaxKind.TypeQuery */:
+            return 5 /* TypePrecedence.TypeOperator */;
+        case 196 /* SyntaxKind.InferType */:
+            return node instanceof InferTypeNode && node.typeParameter.constraint !== undefined
+                ? 2 /* TypePrecedence.Function */
+                : 5 /* TypePrecedence.TypeOperator */;
+        case 200 /* SyntaxKind.IndexedAccessType */:
+        case 189 /* SyntaxKind.ArrayType */:
+        case 191 /* SyntaxKind.OptionalType */:
+            return 6 /* TypePrecedence.Postfix */;
+    }
+    return 7 /* TypePrecedence.NonArray */;
+}
+/** The leftmost operand of an expression, e.g. `a` in `a.b + c`. */
+export function getLeftmostExpression(node, stopAtCallExpressions) {
+    for (;;) {
+        if (node instanceof PostfixUnaryExpression)
+            node = node.operand;
+        else if (node instanceof BinaryExpression)
+            node = node.left;
+        else if (node instanceof ConditionalExpression)
+            node = node.condition;
+        else if (node instanceof TaggedTemplateExpression)
+            node = node.tag;
+        else if (node instanceof PartiallyEmittedExpression)
+            node = node.expression;
+        else if (node instanceof CallExpression) {
+            if (stopAtCallExpressions)
+                return node;
+            node = node.expression;
+        }
+        else if (node instanceof AsExpression ||
+            node instanceof ElementAccessExpression ||
+            node instanceof PropertyAccessExpression ||
+            node instanceof NonNullExpression ||
+            node instanceof PartiallyEmittedExpression ||
+            node instanceof SatisfiesExpression) {
+            const expression = getExpression(node);
+            if (expression === undefined)
+                return node;
+            node = expression;
+        }
+        else
+            return node;
+    }
+}
+export function skipSynthesizedParentheses(node) {
+    while (node instanceof ParenthesizedExpression && nodeIsSynthesized(node))
+        node = node.expression;
+    return node;
+}
+export function isNewExpressionWithoutArguments(node) {
+    return node instanceof NewExpression && node.arguments === undefined;
+}
+export function isBinaryOperation(node, token) {
+    node = skipPartiallyEmittedExpressions(node);
+    return node instanceof BinaryExpression && node.operatorToken.kind === token;
+}
+export function mixingBinaryOperatorsRequiresParentheses(a, b) {
+    if (a === 60 /* SyntaxKind.QuestionQuestionToken */)
+        return b === 55 /* SyntaxKind.AmpersandAmpersandToken */ || b === 56 /* SyntaxKind.BarBarToken */;
+    if (b === 60 /* SyntaxKind.QuestionQuestionToken */)
+        return a === 55 /* SyntaxKind.AmpersandAmpersandToken */ || a === 56 /* SyntaxKind.BarBarToken */;
+    return false;
+}
+export function isImmediatelyInvokedFunctionExpressionOrArrowFunction(node) {
+    node = skipPartiallyEmittedExpressions(node);
+    if (!(node instanceof CallExpression))
+        return false;
+    const callee = skipPartiallyEmittedExpressions(node.expression);
+    return callee.kind === 219 /* SyntaxKind.FunctionExpression */ || callee.kind === 220 /* SyntaxKind.ArrowFunction */;
+}
+export function getOperatorOfPrefixOperand(node) {
+    return node instanceof PrefixUnaryExpression ? node.operator : 0 /* SyntaxKind.Unknown */;
+}
+const hexDigits = '0123456789ABCDEF';
+function hex(code) {
+    let s = '';
+    do {
+        s = hexDigits.charAt(code & 15) + s;
+        code = code >>> 4;
+    } while (code > 0);
+    return s;
+}
+function utf16Escape(code) {
+    const digits = hex(code);
+    return '\\u' + '0000'.substring(digits.length) + digits;
+}
+function escapedChar(ch) {
+    switch (ch) {
+        case 9 /* CharacterCodes.tab */:
+            return '\\t';
+        case 11 /* CharacterCodes.verticalTab */:
+            return '\\v';
+        case 12 /* CharacterCodes.formFeed */:
+            return '\\f';
+        case 8 /* CharacterCodes.backspace */:
+            return '\\b';
+        case 13 /* CharacterCodes.carriageReturn */:
+            return '\\r';
+        case 10 /* CharacterCodes.lineFeed */:
+            return '\\n';
+        case 92 /* CharacterCodes.backslash */:
+            return '\\\\';
+        case 34 /* CharacterCodes.doubleQuote */:
+            return '\\"';
+        case 39 /* CharacterCodes.singleQuote */:
+            return "\\'";
+        case 96 /* CharacterCodes.backtick */:
+            return '\\`';
+        case 36 /* CharacterCodes.$ */:
+            return '\\$';
+        case 8232 /* CharacterCodes.lineSeparator */:
+            return '\\u2028';
+        case 8233 /* CharacterCodes.paragraphSeparator */:
+            return '\\u2029';
+        case 133 /* CharacterCodes.nextLine */:
+            return '\\u0085';
+    }
+    return utf16Escape(ch);
+}
+/**
+ * Escapes `s` for a literal quoted with `quote`, as ECMA-262's QuoteJSONString plus LS, PS
+ * and NEL; non-ASCII characters too unless `NeverAsciiEscape` is set. Doesn't add quotes.
+ */
+export function escapeString(s, quote, flags) {
+    let out = '';
+    let start = 0;
+    const length = s.length;
+    for (let i = 0; i < length;) {
+        let ch = s.charCodeAt(i);
+        let size = 1;
+        if (ch >= 0xd800 && ch <= 0xdbff && i + 1 < length) {
+            const low = s.charCodeAt(i + 1);
+            if (low >= 0xdc00 && low <= 0xdfff) {
+                ch = (ch - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000;
+                size = 2;
+            }
+        }
+        let escape = ch >= 0xd800 && ch <= 0xdfff;
+        switch (ch) {
+            case 92 /* CharacterCodes.backslash */:
+                if ((flags & 2 /* LiteralTextFlags.JsxAttributeEscape */) === 0)
+                    escape = true;
+                break;
+            case 36 /* CharacterCodes.$ */:
+                if (quote === 96 /* CharacterCodes.backtick */ && i + 1 < length && s.charCodeAt(i + 1) === 123 /* CharacterCodes.openBrace */)
+                    escape = true;
+                break;
+            case 8232 /* CharacterCodes.lineSeparator */:
+            case 8233 /* CharacterCodes.paragraphSeparator */:
+            case 133 /* CharacterCodes.nextLine */:
+            case 13 /* CharacterCodes.carriageReturn */:
+                escape = true;
+                break;
+            case 10 /* CharacterCodes.lineFeed */:
+                if (quote !== 96 /* CharacterCodes.backtick */)
+                    escape = true;
+                break;
+            default:
+                if (ch === quote || ch <= 0x1f || ((flags & 1 /* LiteralTextFlags.NeverAsciiEscape */) === 0 && ch > 0x7f))
+                    escape = true;
+        }
+        if (escape) {
+            if (start < i)
+                out += s.substring(start, i);
+            if ((flags & 2 /* LiteralTextFlags.JsxAttributeEscape */) !== 0) {
+                if (ch === 0)
+                    out += '&#0;';
+                else if (ch === 34 /* CharacterCodes.doubleQuote */)
+                    out += '&quot;';
+                else if (ch === 39 /* CharacterCodes.singleQuote */)
+                    out += '&apos;';
+                else
+                    out += '&#x' + hex(ch) + ';';
+            }
+            else if (ch === 13 /* CharacterCodes.carriageReturn */ &&
+                quote === 96 /* CharacterCodes.backtick */ &&
+                i + 1 < length &&
+                s.charCodeAt(i + 1) === 10 /* CharacterCodes.lineFeed */) {
+                size++;
+                out += '\\r\\n';
+            }
+            else if (ch > 0xffff) {
+                const c = ch - 0x10000;
+                out += utf16Escape((c >> 10) + 0xd800) + utf16Escape((c & 0x3ff) + 0xdc00);
+            }
+            else if (ch === 0) {
+                out += i + 1 < length && isDigit(s.charCodeAt(i + 1)) ? '\\x00' : '\\0';
+            }
+            else
+                out += escapedChar(ch);
+            start = i + size;
+        }
+        i += size;
+    }
+    if (start === 0)
+        return s;
+    if (start < length)
+        out += s.substring(start);
+    return out;
+}
+function canUseOriginalText(node, flags) {
+    if (nodeIsSynthesized(node) ||
+        node.parent === undefined ||
+        ((flags & 4 /* LiteralTextFlags.TerminateUnterminatedLiterals */) !== 0 && isUnterminatedLiteral(node)))
+        return false;
+    if (node instanceof NumericLiteral) {
+        if ((node.tokenFlags & 26656 /* TokenFlags.IsInvalid */) !== 0)
+            return false;
+        if ((node.tokenFlags & 512 /* TokenFlags.ContainsSeparator */) !== 0)
+            return (flags & 8 /* LiteralTextFlags.AllowNumericSeparator */) !== 0;
+    }
+    return node.kind !== 9 /* SyntaxKind.BigIntLiteral */;
+}
+function templateText(open, text, rawText, close, flags) {
+    if (rawText.length > 0 || text.length === 0)
+        return open + rawText + close;
+    return open + escapeString(text, 96 /* CharacterCodes.backtick */, flags) + close;
+}
+/** The text of a literal as written, or its canonical (escaped, quoted) form for synthesized literals. */
+export function getLiteralText(node, sourceText, flags) {
+    if (sourceText !== undefined && canUseOriginalText(node, flags))
+        return getSourceTextOfNode(sourceText, node);
+    if (node instanceof StringLiteral) {
+        const quote = (node.tokenFlags & 65536 /* TokenFlags.SingleQuote */) !== 0 ? 39 /* CharacterCodes.singleQuote */ : 34 /* CharacterCodes.doubleQuote */;
+        const q = quote === 39 /* CharacterCodes.singleQuote */ ? "'" : '"';
+        return q + escapeString(node.text, quote, flags) + q;
+    }
+    if (node instanceof NoSubstitutionTemplateLiteral)
+        return templateText('`', node.text, '', '`', flags);
+    if (node instanceof TemplateHead)
+        return templateText('`', node.text, node.rawText, '${', flags);
+    if (node instanceof TemplateMiddle)
+        return templateText('}', node.text, node.rawText, '${', flags);
+    if (node instanceof TemplateTail)
+        return templateText('}', node.text, node.rawText, '`', flags);
+    if (node instanceof NumericLiteral)
+        return node.text;
+    if (node instanceof BigIntLiteral)
+        return node.text;
+    if (node instanceof RegularExpressionLiteral) {
+        const text = node.text;
+        if ((flags & 4 /* LiteralTextFlags.TerminateUnterminatedLiterals */) !== 0 && isUnterminatedLiteral(node))
+            return text.length > 0 && text.charCodeAt(text.length - 1) === 92 /* CharacterCodes.backslash */
+                ? text + ' /'
+                : text + '/';
+        return text;
+    }
+    throw new Error('Unsupported literal');
+}
+/** The source text of a node without leading trivia, as tsgo's GetSourceTextOfNodeFromSourceFile. */
+export function getSourceTextOfNode(sourceText, node) {
+    if (node.pos === node.end && node.pos >= 0 && node.kind !== 1 /* SyntaxKind.EndOfFile */)
+        return '';
+    const text = sourceText.substring(skipTrivia(sourceText, node.pos), node.end);
+    if ((node.flags & 268435456 /* NodeFlags.ReparserTransformedLiteral */) !== 0) {
+        if (node instanceof StringLiteral)
+            return (node.tokenFlags & 65536 /* TokenFlags.SingleQuote */) !== 0 ? "'" + text + "'" : '"' + text + '"';
+        return getTextOfIdentifierLike(node);
+    }
+    return text;
+}
+function getTextOfIdentifierLike(node) {
+    if (node instanceof Identifier)
+        return node.text;
+    if (node instanceof PrivateIdentifier)
+        return node.text;
+    throw new Error('Unexpected reparser-transformed node kind');
+}
+// Lines
+/** Go's `strings.TrimSpace`: trims Unicode White_Space. */
+export function trimUnicodeSpace(text, start, end) {
+    while (start < end && isUnicodeWhiteSpace(text.charCodeAt(start)))
+        start++;
+    while (end > start && isUnicodeWhiteSpace(text.charCodeAt(end - 1)))
+        end--;
+    return text.substring(start, end);
+}
+/** The zero-based line of `pos`, searching from line `low`. */
+function lineOfPosition(lineStarts, pos, low) {
+    let high = lineStarts.length - 1;
+    while (low <= high) {
+        const middle = low + ((high - low) >> 1);
+        const value = lineStarts[middle] | 0;
+        if (value < pos)
+            low = middle + 1;
+        else if (value > pos)
+            high = middle - 1;
+        else
+            return middle;
+    }
+    return low - 1;
+}
+export function getLinesBetweenPositions(lineStarts, pos1, pos2) {
+    if (pos1 === pos2)
+        return 0;
+    const negative = pos2 < pos1;
+    const lower = negative ? pos2 : pos1;
+    const upper = negative ? pos1 : pos2;
+    const lowerLine = computeLineOfPosition(lineStarts, lower);
+    const upperLine = lineOfPosition(lineStarts, upper, lowerLine < 0 ? 0 : lowerLine);
+    return negative ? lowerLine - upperLine : upperLine - lowerLine;
+}
+export function getStartPositionOfRange(text, pos, includeComments) {
+    if (pos < 0)
+        return -1;
+    return skipTrivia(text, pos, false, includeComments);
+}
+export function getPreviousNonWhitespacePosition(text, pos, stopPos) {
+    for (; pos >= stopPos; pos--)
+        if (!isWhiteSpaceLike(text.charCodeAt(pos)))
+            return pos;
+    return -1;
+}
+/** Columns of leading whitespace in `text[pos:end]`, with tabs to the next multiple of 4. */
+export function calculateIndent(text, pos, end) {
+    let indent = 0;
+    for (; pos < end; pos++) {
+        const ch = text.charCodeAt(pos);
+        if (!isWhiteSpaceSingleLine(ch))
+            break;
+        if (ch === 9 /* CharacterCodes.tab */)
+            indent += 4 - (indent & 3);
+        else
+            indent++;
+    }
+    return indent;
+}
+export function isLineBreakChar(ch) {
+    return isLineBreak(ch);
+}
+// Comments
+export function isJSDocLikeText(text, comment) {
+    return (comment.kind === 3 /* SyntaxKind.MultiLineCommentTrivia */ &&
+        comment.end - comment.pos >= 5 &&
+        text.charCodeAt(comment.pos + 2) === 42 /* CharacterCodes.asterisk */ &&
+        text.charCodeAt(comment.pos + 3) !== 47 /* CharacterCodes.slash */);
+}
+export function isPinnedComment(text, comment) {
+    return (comment.kind === 3 /* SyntaxKind.MultiLineCommentTrivia */ &&
+        comment.end - comment.pos > 5 &&
+        text.charCodeAt(comment.pos + 2) === 33 /* CharacterCodes.exclamation */);
+}
+function skipWhiteSpaceSingleLine(text, pos) {
+    while (pos < text.length && isWhiteSpaceSingleLine(text.charCodeAt(pos)))
+        pos++;
+    return pos;
+}
+function skipQuotedString(text, pos) {
+    const quote = text.charCodeAt(pos);
+    if (quote !== 39 /* CharacterCodes.singleQuote */ && quote !== 34 /* CharacterCodes.doubleQuote */)
+        return -1;
+    const close = text.indexOf(quote === 39 /* CharacterCodes.singleQuote */ ? "'" : '"', pos + 1);
+    return close < 0 ? -1 : close + 1;
+}
+function skipAttribute(text, pos, names) {
+    const next = skipWhiteSpaceSingleLine(text, pos);
+    if (next === pos)
+        return -1;
+    pos = next;
+    let matched = false;
+    for (const name of names) {
+        if (text.startsWith(name, pos)) {
+            pos += name.length;
+            matched = true;
+            break;
+        }
+    }
+    if (!matched)
+        return -1;
+    pos = skipWhiteSpaceSingleLine(text, pos);
+    if (text.charCodeAt(pos) !== 61 /* CharacterCodes.equals */)
+        return -1;
+    return skipQuotedString(text, skipWhiteSpaceSingleLine(text, pos + 1));
+}
+const referenceAttributes = ['path', 'types', 'lib', 'no-default-lib'];
+const amdDependencyAttributes = ['path'];
+/** `/// <reference …/>`, `/// <amd-dependency path="…"/>` and `/// <amd-module/>` comments. */
+export function isRecognizedTripleSlashComment(sourceText, comment) {
+    if (comment.kind !== 2 /* SyntaxKind.SingleLineCommentTrivia */ ||
+        comment.end - comment.pos <= 2 ||
+        sourceText.charCodeAt(comment.pos + 1) !== 47 /* CharacterCodes.slash */ ||
+        sourceText.charCodeAt(comment.pos + 2) !== 47 /* CharacterCodes.slash */)
+        return false;
+    const text = sourceText.substring(comment.pos + 3, comment.end);
+    let pos = skipWhiteSpaceSingleLine(text, 0);
+    if (text.charCodeAt(pos) !== 60 /* CharacterCodes.lessThan */)
+        return false;
+    pos++;
+    if (text.startsWith('reference', pos))
+        pos = skipAttribute(text, pos + 9, referenceAttributes);
+    else if (text.startsWith('amd-dependency', pos))
+        pos = skipAttribute(text, pos + 14, amdDependencyAttributes);
+    else if (text.startsWith('amd-module', pos))
+        pos = skipWhiteSpaceSingleLine(text, pos + 10);
+    else
+        return false;
+    return pos >= 0 && text.indexOf('/>', pos) >= 0;
+}
+// Names
+export function formatGeneratedName(privateName, prefix, base, suffix) {
+    const name = removeLeadingHash(prefix) + removeLeadingHash(base) + removeLeadingHash(suffix);
+    return privateName ? ensureLeadingHash(name) : name;
+}
+export function removeLeadingHash(text) {
+    return text.length > 0 && text.charCodeAt(0) === 35 /* CharacterCodes.hash */ ? text.substring(1) : text;
+}
+export function ensureLeadingHash(text) {
+    return text.length > 0 && text.charCodeAt(0) === 35 /* CharacterCodes.hash */ ? text : '#' + text;
+}
+function isASCIIWordCharacter(ch) {
+    return ((ch >= 97 /* CharacterCodes.a */ && ch <= 122 /* CharacterCodes.z */) ||
+        (ch >= 65 /* CharacterCodes.A */ && ch <= 90 /* CharacterCodes.Z */) ||
+        isDigit(ch) ||
+        ch === 95 /* CharacterCodes._ */);
+}
+/** An identifier for a module's base name, e.g. `foo_bar` for `./foo-bar`; one `_` per UTF-8 byte of other characters. */
+export function makeIdentifierFromModuleName(moduleName) {
+    moduleName = getBaseFileName(moduleName);
+    let out = '';
+    let start = 0;
+    for (let pos = 0; pos < moduleName.length; pos++) {
+        const ch = moduleName.charCodeAt(pos);
+        if (pos === 0 && isDigit(ch))
+            out += '_';
+        else if (!isASCIIWordCharacter(ch)) {
+            if (start < pos)
+                out += moduleName.substring(start, pos);
+            if (ch < 0x80)
+                out += '_';
+            else if (ch < 0x800)
+                out += '__';
+            else if (ch >= 0xd800 && ch <= 0xdbff && pos + 1 < moduleName.length) {
+                out += '____';
+                pos++;
+            }
+            else
+                out += '___';
+            start = pos + 1;
+        }
+    }
+    if (start < moduleName.length)
+        out += moduleName.substring(start);
+    return out;
+}
+export function lineOf(lineStarts, pos) {
+    return computeLineOfPosition(lineStarts, pos);
+}