@tslite/parser 1.10.0 → 1.12.0

package/dist/factoryPublic.js

@@ -0,0 +1,1796 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/factoryPublic.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, addRange, append, createNode, createScanner, emptyArray, escapeLeadingUnderscores, getEmitFlags, getParseTreeNode, getSourceFileOfNode, getTextOfIdentifierOrLiteral, idText, isArray, isBinaryExpression, isCommaSequence, isIdentifier, isNodeArray, isNotEmittedStatement, isOptionalChain, isParseTreeNode, isPropertyAccessChain, isString, nodeIsSynthesized, parenthesizeArrayTypeMember, parenthesizeBinaryOperand, parenthesizeConciseBody, parenthesizeConditionalTypeMember, parenthesizeDefaultExpression, parenthesizeElementTypeMember, parenthesizeElementTypeMembers, parenthesizeExpressionForExpressionStatement, parenthesizeExpressionForList, parenthesizeForAccess, parenthesizeForConditionalHead, parenthesizeListElements, parenthesizePostfixOperand, parenthesizePrefixOperand, parenthesizeSubexpressionOfConditionalExpression, parenthesizeTypeParameters, pseudoBigIntToString, sameFlatMap, stringToToken, } from "./_namespaces/ts.js";
+function createSynthesizedNode(kind) {
+    const node = createNode(kind, -1, -1);
+    node.flags |= 8 /* NodeFlags.Synthesized */;
+    return node;
+}
+export function updateNode(updated, original) {
+    if (updated !== original) {
+        setOriginalNode(updated, original);
+        setTextRange(updated, original);
+    }
+    return updated;
+}
+/**
+ * Make `elements` into a `NodeArray<T>`. If `elements` is `undefined`, returns an empty `NodeArray<T>`.
+ */
+export function createNodeArray(elements, hasTrailingComma) {
+    if (!elements || elements === emptyArray) {
+        elements = [];
+    }
+    else if (isNodeArray(elements)) {
+        return elements;
+    }
+    const array = elements;
+    array.pos = -1;
+    array.end = -1;
+    array.hasTrailingComma = hasTrailingComma;
+    return array;
+}
+/**
+ * Creates a shallow, memberwise clone of a node with no source map location.
+ */
+export function getSynthesizedClone(node) {
+    // We don't use "clone" from core.ts here, as we need to preserve the prototype chain of
+    // the original node. We also need to exclude specific properties and only include own-
+    // properties (to skip members already defined on the shared prototype).
+    if (node === undefined) {
+        return node;
+    }
+    const clone = createSynthesizedNode(node.kind);
+    clone.flags |= node.flags;
+    setOriginalNode(clone, node);
+    for (const key in node) {
+        if (clone.hasOwnProperty(key) || !node.hasOwnProperty(key)) {
+            continue;
+        }
+        clone[key] = node[key];
+    }
+    return clone;
+}
+export function createLiteral(value, isSingleQuote) {
+    if (typeof value === "number") {
+        return createNumericLiteral(value + "");
+    }
+    // eslint-disable-next-line no-in-operator
+    if (typeof value === "object" && "base10Value" in value) { // PseudoBigInt
+        return createBigIntLiteral(pseudoBigIntToString(value) + "n");
+    }
+    if (typeof value === "boolean") {
+        return value ? createTrue() : createFalse();
+    }
+    if (isString(value)) {
+        const res = createStringLiteral(value);
+        if (isSingleQuote)
+            res.singleQuote = true;
+        return res;
+    }
+    return createLiteralFromNode(value);
+}
+export function createNumericLiteral(value, numericLiteralFlags = 0 /* TokenFlags.None */) {
+    const node = createSynthesizedNode(8 /* SyntaxKind.NumericLiteral */);
+    node.text = value;
+    node.numericLiteralFlags = numericLiteralFlags;
+    return node;
+}
+export function createBigIntLiteral(value) {
+    const node = createSynthesizedNode(9 /* SyntaxKind.BigIntLiteral */);
+    node.text = value;
+    return node;
+}
+export function createStringLiteral(text) {
+    const node = createSynthesizedNode(10 /* SyntaxKind.StringLiteral */);
+    node.text = text;
+    return node;
+}
+function createLiteralFromNode(sourceNode) {
+    const node = createStringLiteral(getTextOfIdentifierOrLiteral(sourceNode));
+    node.textSourceNode = sourceNode;
+    return node;
+}
+export function createIdentifier(text, typeArguments) {
+    const node = createSynthesizedNode(75 /* SyntaxKind.Identifier */);
+    node.escapedText = escapeLeadingUnderscores(text);
+    node.originalKeywordKind = text ? stringToToken(text) : 0 /* SyntaxKind.Unknown */;
+    node.autoGenerateFlags = 0 /* GeneratedIdentifierFlags.None */;
+    node.autoGenerateId = 0;
+    if (typeArguments) {
+        node.typeArguments = createNodeArray(typeArguments);
+    }
+    return node;
+}
+export function updateIdentifier(node, typeArguments) {
+    return node.typeArguments !== typeArguments
+        ? updateNode(createIdentifier(idText(node), typeArguments), node)
+        : node;
+}
+let nextAutoGenerateId = 0;
+export function createOptimisticUniqueName(text) {
+    const name = createIdentifier(text);
+    name.autoGenerateFlags = 3 /* GeneratedIdentifierFlags.Unique */ | 16 /* GeneratedIdentifierFlags.Optimistic */;
+    name.autoGenerateId = nextAutoGenerateId;
+    nextAutoGenerateId++;
+    return name;
+}
+export function getGeneratedNameForNode(node, flags) {
+    const name = createIdentifier(node && isIdentifier(node) ? idText(node) : "");
+    name.autoGenerateFlags = 4 /* GeneratedIdentifierFlags.Node */ | flags;
+    name.autoGenerateId = nextAutoGenerateId;
+    name.original = node;
+    nextAutoGenerateId++;
+    return name;
+}
+// Punctuation
+export function createToken(token) {
+    return createSynthesizedNode(token);
+}
+// Reserved words
+export function createTrue() {
+    return createSynthesizedNode(106 /* SyntaxKind.TrueKeyword */);
+}
+export function createFalse() {
+    return createSynthesizedNode(91 /* SyntaxKind.FalseKeyword */);
+}
+// Modifiers
+export function createModifier(kind) {
+    return createToken(kind);
+}
+/** Na tag, também o `default`, o `const` de um enum e os modificadores de classe (CK-02). */
+export function createModifiersFromModifierFlags(flags) {
+    const result = [];
+    if (flags & 1 /* ModifierFlags.Export */) {
+        result.push(createModifier(89 /* SyntaxKind.ExportKeyword */));
+    }
+    if (flags & 2 /* ModifierFlags.Ambient */) {
+        result.push(createModifier(130 /* SyntaxKind.DeclareKeyword */));
+    }
+    if (flags & 64 /* ModifierFlags.Readonly */) {
+        result.push(createModifier(138 /* SyntaxKind.ReadonlyKeyword */));
+    }
+    if (flags & 256 /* ModifierFlags.Async */) {
+        result.push(createModifier(126 /* SyntaxKind.AsyncKeyword */));
+    }
+    return result;
+}
+// Names
+export function createQualifiedName(left, right) {
+    const node = createSynthesizedNode(153 /* SyntaxKind.QualifiedName */);
+    node.left = left;
+    node.right = asName(right);
+    return node;
+}
+export function updateQualifiedName(node, left, right) {
+    return node.left !== left
+        || node.right !== right
+        ? updateNode(createQualifiedName(left, right), node)
+        : node;
+}
+function parenthesizeForComputedName(expression) {
+    return isCommaSequence(expression)
+        ? createParen(expression)
+        : expression;
+}
+export function createComputedPropertyName(expression) {
+    const node = createSynthesizedNode(154 /* SyntaxKind.ComputedPropertyName */);
+    node.expression = parenthesizeForComputedName(expression);
+    return node;
+}
+export function updateComputedPropertyName(node, expression) {
+    return node.expression !== expression
+        ? updateNode(createComputedPropertyName(expression), node)
+        : node;
+}
+// Signature elements
+export function createTypeParameterDeclaration(name, constraint, defaultType) {
+    const node = createSynthesizedNode(155 /* SyntaxKind.TypeParameter */);
+    node.name = asName(name);
+    node.constraint = constraint;
+    node.default = defaultType;
+    return node;
+}
+export function updateTypeParameterDeclaration(node, name, constraint, defaultType) {
+    return node.name !== name
+        || node.constraint !== constraint
+        || node.default !== defaultType
+        ? updateNode(createTypeParameterDeclaration(name, constraint, defaultType), node)
+        : node;
+}
+export function createParameter(modifiers, dotDotDotToken, name, questionToken, type, initializer) {
+    const node = createSynthesizedNode(156 /* SyntaxKind.Parameter */);
+    node.modifiers = asNodeArray(modifiers);
+    node.dotDotDotToken = dotDotDotToken;
+    node.name = asName(name);
+    node.questionToken = questionToken;
+    node.type = type;
+    node.initializer = initializer ? parenthesizeExpressionForList(initializer) : undefined;
+    return node;
+}
+export function updateParameter(node, modifiers, dotDotDotToken, name, questionToken, type, initializer) {
+    return node.modifiers !== modifiers
+        || node.dotDotDotToken !== dotDotDotToken
+        || node.name !== name
+        || node.questionToken !== questionToken
+        || node.type !== type
+        || node.initializer !== initializer
+        ? updateNode(createParameter(modifiers, dotDotDotToken, name, questionToken, type, initializer), node)
+        : node;
+}
+// Type Elements
+export function createPropertySignature(modifiers, name, questionToken, type, initializer) {
+    const node = createSynthesizedNode(158 /* SyntaxKind.PropertySignature */);
+    node.modifiers = asNodeArray(modifiers);
+    node.name = asName(name);
+    node.questionToken = questionToken;
+    node.type = type;
+    node.initializer = initializer;
+    return node;
+}
+export function updatePropertySignature(node, modifiers, name, questionToken, type, initializer) {
+    return node.modifiers !== modifiers
+        || node.name !== name
+        || node.questionToken !== questionToken
+        || node.type !== type
+        || node.initializer !== initializer
+        ? updateNode(createPropertySignature(modifiers, name, questionToken, type, initializer), node)
+        : node;
+}
+export function createMethodSignature(typeParameters, parameters, type, name, questionToken) {
+    const node = createSignatureDeclaration(160 /* SyntaxKind.MethodSignature */, typeParameters, parameters, type);
+    node.name = asName(name);
+    node.questionToken = questionToken;
+    return node;
+}
+export function updateMethodSignature(node, typeParameters, parameters, type, name, questionToken) {
+    return node.typeParameters !== typeParameters
+        || node.parameters !== parameters
+        || node.type !== type
+        || node.name !== name
+        || node.questionToken !== questionToken
+        ? updateNode(createMethodSignature(typeParameters, parameters, type, name, questionToken), node)
+        : node;
+}
+export function updateCallSignature(node, typeParameters, parameters, type) {
+    return updateSignatureDeclaration(node, typeParameters, parameters, type);
+}
+export function createIndexSignature(modifiers, parameters, type) {
+    const node = createSynthesizedNode(167 /* SyntaxKind.IndexSignature */);
+    node.modifiers = asNodeArray(modifiers);
+    node.parameters = createNodeArray(parameters);
+    node.type = type;
+    return node;
+}
+export function updateIndexSignature(node, modifiers, parameters, type) {
+    return node.parameters !== parameters
+        || node.type !== type
+        || node.modifiers !== modifiers
+        ? updateNode(createIndexSignature(modifiers, parameters, type), node)
+        : node;
+}
+export function createSignatureDeclaration(kind, typeParameters, parameters, type, typeArguments) {
+    const node = createSynthesizedNode(kind);
+    node.typeParameters = asNodeArray(typeParameters);
+    node.parameters = asNodeArray(parameters);
+    node.type = type;
+    node.typeArguments = asNodeArray(typeArguments);
+    return node;
+}
+function updateSignatureDeclaration(node, typeParameters, parameters, type) {
+    return node.typeParameters !== typeParameters
+        || node.parameters !== parameters
+        || node.type !== type
+        ? updateNode(createSignatureDeclaration(node.kind, typeParameters, parameters, type), node)
+        : node;
+}
+// Types
+export function createKeywordTypeNode(kind) {
+    return createSynthesizedNode(kind);
+}
+export function createTypePredicateNodeWithModifier(assertsModifier, parameterName, type) {
+    const node = createSynthesizedNode(168 /* SyntaxKind.TypePredicate */);
+    node.assertsModifier = assertsModifier;
+    node.parameterName = asName(parameterName);
+    node.type = type;
+    return node;
+}
+export function updateTypePredicateNodeWithModifier(node, assertsModifier, parameterName, type) {
+    return node.assertsModifier !== assertsModifier
+        || node.parameterName !== parameterName
+        || node.type !== type
+        ? updateNode(createTypePredicateNodeWithModifier(assertsModifier, parameterName, type), node)
+        : node;
+}
+export function createTypeReferenceNode(typeName, typeArguments) {
+    const node = createSynthesizedNode(169 /* SyntaxKind.TypeReference */);
+    node.typeName = asName(typeName);
+    node.typeArguments = typeArguments && parenthesizeTypeParameters(typeArguments);
+    return node;
+}
+export function updateTypeReferenceNode(node, typeName, typeArguments) {
+    return node.typeName !== typeName
+        || node.typeArguments !== typeArguments
+        ? updateNode(createTypeReferenceNode(typeName, typeArguments), node)
+        : node;
+}
+export function createFunctionTypeNode(typeParameters, parameters, type) {
+    return createSignatureDeclaration(170 /* SyntaxKind.FunctionType */, typeParameters, parameters, type);
+}
+export function updateFunctionTypeNode(node, typeParameters, parameters, type) {
+    return updateSignatureDeclaration(node, typeParameters, parameters, type);
+}
+export function createTypeQueryNode(exprName) {
+    const node = createSynthesizedNode(172 /* SyntaxKind.TypeQuery */);
+    node.exprName = exprName;
+    return node;
+}
+export function updateTypeQueryNode(node, exprName) {
+    return node.exprName !== exprName
+        ? updateNode(createTypeQueryNode(exprName), node)
+        : node;
+}
+export function createTypeLiteralNode(members) {
+    const node = createSynthesizedNode(173 /* SyntaxKind.TypeLiteral */);
+    node.members = createNodeArray(members);
+    return node;
+}
+export function updateTypeLiteralNode(node, members) {
+    return node.members !== members
+        ? updateNode(createTypeLiteralNode(members), node)
+        : node;
+}
+export function createArrayTypeNode(elementType) {
+    const node = createSynthesizedNode(174 /* SyntaxKind.ArrayType */);
+    node.elementType = parenthesizeArrayTypeMember(elementType);
+    return node;
+}
+export function updateArrayTypeNode(node, elementType) {
+    return node.elementType !== elementType
+        ? updateNode(createArrayTypeNode(elementType), node)
+        : node;
+}
+export function createTupleTypeNode(elementTypes) {
+    const node = createSynthesizedNode(175 /* SyntaxKind.TupleType */);
+    node.elementTypes = createNodeArray(elementTypes);
+    return node;
+}
+export function updateTupleTypeNode(node, elementTypes) {
+    return node.elementTypes !== elementTypes
+        ? updateNode(createTupleTypeNode(elementTypes), node)
+        : node;
+}
+export function createOptionalTypeNode(type) {
+    const node = createSynthesizedNode(176 /* SyntaxKind.OptionalType */);
+    node.type = parenthesizeArrayTypeMember(type);
+    return node;
+}
+export function updateOptionalTypeNode(node, type) {
+    return node.type !== type
+        ? updateNode(createOptionalTypeNode(type), node)
+        : node;
+}
+export function createRestTypeNode(type) {
+    const node = createSynthesizedNode(177 /* SyntaxKind.RestType */);
+    node.type = type;
+    return node;
+}
+export function updateRestTypeNode(node, type) {
+    return node.type !== type
+        ? updateNode(createRestTypeNode(type), node)
+        : node;
+}
+export function createUnionTypeNode(types) {
+    return createUnionOrIntersectionTypeNode(178 /* SyntaxKind.UnionType */, types);
+}
+export function updateUnionTypeNode(node, types) {
+    return updateUnionOrIntersectionTypeNode(node, types);
+}
+export function createIntersectionTypeNode(types) {
+    return createUnionOrIntersectionTypeNode(179 /* SyntaxKind.IntersectionType */, types);
+}
+export function updateIntersectionTypeNode(node, types) {
+    return updateUnionOrIntersectionTypeNode(node, types);
+}
+export function createUnionOrIntersectionTypeNode(kind, types) {
+    const node = createSynthesizedNode(kind);
+    node.types = parenthesizeElementTypeMembers(types);
+    return node;
+}
+function updateUnionOrIntersectionTypeNode(node, types) {
+    return node.types !== types
+        ? updateNode(createUnionOrIntersectionTypeNode(node.kind, types), node)
+        : node;
+}
+export function createConditionalTypeNode(checkType, extendsType, trueType, falseType) {
+    const node = createSynthesizedNode(180 /* SyntaxKind.ConditionalType */);
+    node.checkType = parenthesizeConditionalTypeMember(checkType);
+    node.extendsType = parenthesizeConditionalTypeMember(extendsType);
+    node.trueType = trueType;
+    node.falseType = falseType;
+    return node;
+}
+export function updateConditionalTypeNode(node, checkType, extendsType, trueType, falseType) {
+    return node.checkType !== checkType
+        || node.extendsType !== extendsType
+        || node.trueType !== trueType
+        || node.falseType !== falseType
+        ? updateNode(createConditionalTypeNode(checkType, extendsType, trueType, falseType), node)
+        : node;
+}
+export function createInferTypeNode(typeParameter) {
+    const node = createSynthesizedNode(181 /* SyntaxKind.InferType */);
+    node.typeParameter = typeParameter;
+    return node;
+}
+export function updateInferTypeNode(node, typeParameter) {
+    return node.typeParameter !== typeParameter
+        ? updateNode(createInferTypeNode(typeParameter), node)
+        : node;
+}
+export function createImportTypeNode(argument, qualifier, typeArguments, isTypeOf) {
+    const node = createSynthesizedNode(188 /* SyntaxKind.ImportType */);
+    node.argument = argument;
+    node.qualifier = qualifier;
+    node.typeArguments = parenthesizeTypeParameters(typeArguments);
+    node.isTypeOf = isTypeOf;
+    return node;
+}
+export function updateImportTypeNode(node, argument, qualifier, typeArguments, isTypeOf) {
+    return node.argument !== argument
+        || node.qualifier !== qualifier
+        || node.typeArguments !== typeArguments
+        || node.isTypeOf !== isTypeOf
+        ? updateNode(createImportTypeNode(argument, qualifier, typeArguments, isTypeOf), node)
+        : node;
+}
+export function createParenthesizedType(type) {
+    const node = createSynthesizedNode(182 /* SyntaxKind.ParenthesizedType */);
+    node.type = type;
+    return node;
+}
+export function updateParenthesizedType(node, type) {
+    return node.type !== type
+        ? updateNode(createParenthesizedType(type), node)
+        : node;
+}
+export function createTypeOperatorNode(operatorOrType, type) {
+    const node = createSynthesizedNode(184 /* SyntaxKind.TypeOperator */);
+    node.operator = typeof operatorOrType === "number" ? operatorOrType : 134 /* SyntaxKind.KeyOfKeyword */;
+    node.type = parenthesizeElementTypeMember(typeof operatorOrType === "number" ? type : operatorOrType);
+    return node;
+}
+export function updateTypeOperatorNode(node, type) {
+    return node.type !== type ? updateNode(createTypeOperatorNode(node.operator, type), node) : node;
+}
+export function createIndexedAccessTypeNode(objectType, indexType) {
+    const node = createSynthesizedNode(185 /* SyntaxKind.IndexedAccessType */);
+    node.objectType = parenthesizeElementTypeMember(objectType);
+    node.indexType = indexType;
+    return node;
+}
+export function updateIndexedAccessTypeNode(node, objectType, indexType) {
+    return node.objectType !== objectType
+        || node.indexType !== indexType
+        ? updateNode(createIndexedAccessTypeNode(objectType, indexType), node)
+        : node;
+}
+export function createMappedTypeNode(readonlyToken, typeParameter, questionToken, type) {
+    const node = createSynthesizedNode(186 /* SyntaxKind.MappedType */);
+    node.readonlyToken = readonlyToken;
+    node.typeParameter = typeParameter;
+    node.questionToken = questionToken;
+    node.type = type;
+    return node;
+}
+export function updateMappedTypeNode(node, readonlyToken, typeParameter, questionToken, type) {
+    return node.readonlyToken !== readonlyToken
+        || node.typeParameter !== typeParameter
+        || node.questionToken !== questionToken
+        || node.type !== type
+        ? updateNode(createMappedTypeNode(readonlyToken, typeParameter, questionToken, type), node)
+        : node;
+}
+export function createLiteralTypeNode(literal) {
+    const node = createSynthesizedNode(187 /* SyntaxKind.LiteralType */);
+    node.literal = literal;
+    return node;
+}
+export function updateLiteralTypeNode(node, literal) {
+    return node.literal !== literal
+        ? updateNode(createLiteralTypeNode(literal), node)
+        : node;
+}
+// Binding Patterns
+export function createObjectBindingPattern(elements) {
+    const node = createSynthesizedNode(189 /* SyntaxKind.ObjectBindingPattern */);
+    node.elements = createNodeArray(elements);
+    return node;
+}
+export function updateObjectBindingPattern(node, elements) {
+    return node.elements !== elements
+        ? updateNode(createObjectBindingPattern(elements), node)
+        : node;
+}
+export function createArrayBindingPattern(elements) {
+    const node = createSynthesizedNode(190 /* SyntaxKind.ArrayBindingPattern */);
+    node.elements = createNodeArray(elements);
+    return node;
+}
+export function updateArrayBindingPattern(node, elements) {
+    return node.elements !== elements
+        ? updateNode(createArrayBindingPattern(elements), node)
+        : node;
+}
+export function createBindingElement(dotDotDotToken, propertyName, name, initializer) {
+    const node = createSynthesizedNode(191 /* SyntaxKind.BindingElement */);
+    node.dotDotDotToken = dotDotDotToken;
+    node.propertyName = asName(propertyName);
+    node.name = asName(name);
+    node.initializer = initializer;
+    return node;
+}
+export function updateBindingElement(node, dotDotDotToken, propertyName, name, initializer) {
+    return node.propertyName !== propertyName
+        || node.dotDotDotToken !== dotDotDotToken
+        || node.name !== name
+        || node.initializer !== initializer
+        ? updateNode(createBindingElement(dotDotDotToken, propertyName, name, initializer), node)
+        : node;
+}
+// Expression
+export function createArrayLiteral(elements, multiLine) {
+    const node = createSynthesizedNode(192 /* SyntaxKind.ArrayLiteralExpression */);
+    node.elements = parenthesizeListElements(createNodeArray(elements));
+    if (multiLine)
+        node.multiLine = true;
+    return node;
+}
+export function updateArrayLiteral(node, elements) {
+    return node.elements !== elements
+        ? updateNode(createArrayLiteral(elements, node.multiLine), node)
+        : node;
+}
+export function createObjectLiteral(properties, multiLine) {
+    const node = createSynthesizedNode(193 /* SyntaxKind.ObjectLiteralExpression */);
+    node.properties = createNodeArray(properties);
+    if (multiLine)
+        node.multiLine = true;
+    return node;
+}
+export function updateObjectLiteral(node, properties) {
+    return node.properties !== properties
+        ? updateNode(createObjectLiteral(properties, node.multiLine), node)
+        : node;
+}
+export function createPropertyAccess(expression, name) {
+    const node = createSynthesizedNode(194 /* SyntaxKind.PropertyAccessExpression */);
+    node.expression = parenthesizeForAccess(expression);
+    node.name = asName(name);
+    setEmitFlags(node, 131072 /* EmitFlags.NoIndentation */);
+    return node;
+}
+export function updatePropertyAccess(node, expression, name) {
+    if (isPropertyAccessChain(node)) {
+        return updatePropertyAccessChain(node, expression, node.questionDotToken, name);
+    }
+    // Because we are updating existed propertyAccess we want to inherit its emitFlags
+    // instead of using the default from createPropertyAccess
+    return node.expression !== expression
+        || node.name !== name
+        ? updateNode(setEmitFlags(createPropertyAccess(expression, name), getEmitFlags(node)), node)
+        : node;
+}
+export function createPropertyAccessChain(expression, questionDotToken, name) {
+    const node = createSynthesizedNode(194 /* SyntaxKind.PropertyAccessExpression */);
+    node.flags |= 32 /* NodeFlags.OptionalChain */;
+    node.expression = parenthesizeForAccess(expression);
+    node.questionDotToken = questionDotToken;
+    node.name = asName(name);
+    setEmitFlags(node, 131072 /* EmitFlags.NoIndentation */);
+    return node;
+}
+export function updatePropertyAccessChain(node, expression, questionDotToken, name) {
+    Debug.assert(!!(node.flags & 32 /* NodeFlags.OptionalChain */), "Cannot update a PropertyAccessExpression using updatePropertyAccessChain. Use updatePropertyAccess instead.");
+    // Because we are updating an existing PropertyAccessChain we want to inherit its emitFlags
+    // instead of using the default from createPropertyAccess
+    return node.expression !== expression
+        || node.questionDotToken !== questionDotToken
+        || node.name !== name
+        ? updateNode(setEmitFlags(createPropertyAccessChain(expression, questionDotToken, name), getEmitFlags(node)), node)
+        : node;
+}
+export function createElementAccess(expression, index) {
+    const node = createSynthesizedNode(195 /* SyntaxKind.ElementAccessExpression */);
+    node.expression = parenthesizeForAccess(expression);
+    node.argumentExpression = asExpression(index);
+    return node;
+}
+export function updateElementAccess(node, expression, argumentExpression) {
+    if (isOptionalChain(node)) {
+        return updateElementAccessChain(node, expression, node.questionDotToken, argumentExpression);
+    }
+    return node.expression !== expression
+        || node.argumentExpression !== argumentExpression
+        ? updateNode(createElementAccess(expression, argumentExpression), node)
+        : node;
+}
+export function createElementAccessChain(expression, questionDotToken, index) {
+    const node = createSynthesizedNode(195 /* SyntaxKind.ElementAccessExpression */);
+    node.flags |= 32 /* NodeFlags.OptionalChain */;
+    node.expression = parenthesizeForAccess(expression);
+    node.questionDotToken = questionDotToken;
+    node.argumentExpression = asExpression(index);
+    return node;
+}
+export function updateElementAccessChain(node, expression, questionDotToken, argumentExpression) {
+    Debug.assert(!!(node.flags & 32 /* NodeFlags.OptionalChain */), "Cannot update an ElementAccessExpression using updateElementAccessChain. Use updateElementAccess instead.");
+    return node.expression !== expression
+        || node.questionDotToken !== questionDotToken
+        || node.argumentExpression !== argumentExpression
+        ? updateNode(createElementAccessChain(expression, questionDotToken, argumentExpression), node)
+        : node;
+}
+export function createCall(expression, typeArguments, argumentsArray) {
+    const node = createSynthesizedNode(196 /* SyntaxKind.CallExpression */);
+    node.expression = parenthesizeForAccess(expression);
+    node.typeArguments = asNodeArray(typeArguments);
+    node.arguments = parenthesizeListElements(createNodeArray(argumentsArray));
+    return node;
+}
+export function updateCall(node, expression, typeArguments, argumentsArray) {
+    if (isOptionalChain(node)) {
+        return updateCallChain(node, expression, node.questionDotToken, typeArguments, argumentsArray);
+    }
+    return node.expression !== expression
+        || node.typeArguments !== typeArguments
+        || node.arguments !== argumentsArray
+        ? updateNode(createCall(expression, typeArguments, argumentsArray), node)
+        : node;
+}
+export function createCallChain(expression, questionDotToken, typeArguments, argumentsArray) {
+    const node = createSynthesizedNode(196 /* SyntaxKind.CallExpression */);
+    node.flags |= 32 /* NodeFlags.OptionalChain */;
+    node.expression = parenthesizeForAccess(expression);
+    node.questionDotToken = questionDotToken;
+    node.typeArguments = asNodeArray(typeArguments);
+    node.arguments = parenthesizeListElements(createNodeArray(argumentsArray));
+    return node;
+}
+export function updateCallChain(node, expression, questionDotToken, typeArguments, argumentsArray) {
+    Debug.assert(!!(node.flags & 32 /* NodeFlags.OptionalChain */), "Cannot update a CallExpression using updateCallChain. Use updateCall instead.");
+    return node.expression !== expression
+        || node.questionDotToken !== questionDotToken
+        || node.typeArguments !== typeArguments
+        || node.arguments !== argumentsArray
+        ? updateNode(createCallChain(expression, questionDotToken, typeArguments, argumentsArray), node)
+        : node;
+}
+export function createParen(expression) {
+    const node = createSynthesizedNode(200 /* SyntaxKind.ParenthesizedExpression */);
+    node.expression = expression;
+    return node;
+}
+export function updateParen(node, expression) {
+    return node.expression !== expression
+        ? updateNode(createParen(expression), node)
+        : node;
+}
+export function createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body) {
+    const node = createSynthesizedNode(202 /* SyntaxKind.ArrowFunction */);
+    node.modifiers = asNodeArray(modifiers);
+    node.typeParameters = asNodeArray(typeParameters);
+    node.parameters = createNodeArray(parameters);
+    node.type = type;
+    node.equalsGreaterThanToken = equalsGreaterThanToken || createToken(38 /* SyntaxKind.EqualsGreaterThanToken */);
+    node.body = parenthesizeConciseBody(body);
+    return node;
+}
+export function updateArrowFunction(node, modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body) {
+    return node.modifiers !== modifiers
+        || node.typeParameters !== typeParameters
+        || node.parameters !== parameters
+        || node.type !== type
+        || node.equalsGreaterThanToken !== equalsGreaterThanToken
+        || node.body !== body
+        ? updateNode(createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body), node)
+        : node;
+}
+export function createDelete(expression) {
+    const node = createSynthesizedNode(203 /* SyntaxKind.DeleteExpression */);
+    node.expression = parenthesizePrefixOperand(expression);
+    return node;
+}
+export function updateDelete(node, expression) {
+    return node.expression !== expression
+        ? updateNode(createDelete(expression), node)
+        : node;
+}
+export function createTypeOf(expression) {
+    const node = createSynthesizedNode(204 /* SyntaxKind.TypeOfExpression */);
+    node.expression = parenthesizePrefixOperand(expression);
+    return node;
+}
+export function updateTypeOf(node, expression) {
+    return node.expression !== expression
+        ? updateNode(createTypeOf(expression), node)
+        : node;
+}
+export function createAwait(expression) {
+    const node = createSynthesizedNode(206 /* SyntaxKind.AwaitExpression */);
+    node.expression = parenthesizePrefixOperand(expression);
+    return node;
+}
+export function updateAwait(node, expression) {
+    return node.expression !== expression
+        ? updateNode(createAwait(expression), node)
+        : node;
+}
+export function createPrefix(operator, operand) {
+    const node = createSynthesizedNode(207 /* SyntaxKind.PrefixUnaryExpression */);
+    node.operator = operator;
+    node.operand = parenthesizePrefixOperand(operand);
+    return node;
+}
+export function updatePrefix(node, operand) {
+    return node.operand !== operand
+        ? updateNode(createPrefix(node.operator, operand), node)
+        : node;
+}
+export function createPostfix(operand, operator) {
+    const node = createSynthesizedNode(208 /* SyntaxKind.PostfixUnaryExpression */);
+    node.operand = parenthesizePostfixOperand(operand);
+    node.operator = operator;
+    return node;
+}
+export function updatePostfix(node, operand) {
+    return node.operand !== operand
+        ? updateNode(createPostfix(operand, node.operator), node)
+        : node;
+}
+export function createBinary(left, operator, right) {
+    const node = createSynthesizedNode(209 /* SyntaxKind.BinaryExpression */);
+    const operatorToken = asToken(operator);
+    const operatorKind = operatorToken.kind;
+    node.left = parenthesizeBinaryOperand(operatorKind, left, /*isLeftSideOfBinary*/ true, /*leftOperand*/ undefined);
+    node.operatorToken = operatorToken;
+    node.right = parenthesizeBinaryOperand(operatorKind, right, /*isLeftSideOfBinary*/ false, node.left);
+    return node;
+}
+export function updateBinary(node, left, right, operator) {
+    return node.left !== left
+        || node.right !== right
+        ? updateNode(createBinary(left, operator || node.operatorToken, right), node)
+        : node;
+}
+export function createConditional(condition, questionTokenOrWhenTrue, whenTrueOrWhenFalse, colonToken, whenFalse) {
+    const node = createSynthesizedNode(210 /* SyntaxKind.ConditionalExpression */);
+    node.condition = parenthesizeForConditionalHead(condition);
+    node.questionToken = whenFalse ? questionTokenOrWhenTrue : createToken(57 /* SyntaxKind.QuestionToken */);
+    node.whenTrue = parenthesizeSubexpressionOfConditionalExpression(whenFalse ? whenTrueOrWhenFalse : questionTokenOrWhenTrue);
+    node.colonToken = whenFalse ? colonToken : createToken(58 /* SyntaxKind.ColonToken */);
+    node.whenFalse = parenthesizeSubexpressionOfConditionalExpression(whenFalse ? whenFalse : whenTrueOrWhenFalse);
+    return node;
+}
+export function updateConditional(node, condition, questionToken, whenTrue, colonToken, whenFalse) {
+    return node.condition !== condition
+        || node.questionToken !== questionToken
+        || node.whenTrue !== whenTrue
+        || node.colonToken !== colonToken
+        || node.whenFalse !== whenFalse
+        ? updateNode(createConditional(condition, questionToken, whenTrue, colonToken, whenFalse), node)
+        : node;
+}
+export function createTemplateExpression(head, templateSpans) {
+    const node = createSynthesizedNode(211 /* SyntaxKind.TemplateExpression */);
+    node.head = head;
+    node.templateSpans = createNodeArray(templateSpans);
+    return node;
+}
+export function updateTemplateExpression(node, head, templateSpans) {
+    return node.head !== head
+        || node.templateSpans !== templateSpans
+        ? updateNode(createTemplateExpression(head, templateSpans), node)
+        : node;
+}
+let rawTextScanner;
+const invalidValueSentinel = {};
+function getCookedText(kind, rawText) {
+    if (!rawTextScanner) {
+        rawTextScanner = createScanner(99 /* ScriptTarget.Latest */, /*skipTrivia*/ false, 0 /* LanguageVariant.Standard */);
+    }
+    switch (kind) {
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+            rawTextScanner.setText("`" + rawText + "`");
+            break;
+        case 15 /* SyntaxKind.TemplateHead */:
+            rawTextScanner.setText("`" + rawText + "${");
+            break;
+        case 16 /* SyntaxKind.TemplateMiddle */:
+            rawTextScanner.setText("}" + rawText + "${");
+            break;
+        case 17 /* SyntaxKind.TemplateTail */:
+            rawTextScanner.setText("}" + rawText + "`");
+            break;
+    }
+    let token = rawTextScanner.scan();
+    if (token === 19 /* SyntaxKind.CloseBraceToken */) {
+        token = rawTextScanner.reScanTemplateToken();
+    }
+    if (rawTextScanner.isUnterminated()) {
+        rawTextScanner.setText(undefined);
+        return invalidValueSentinel;
+    }
+    let tokenValue;
+    switch (token) {
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 15 /* SyntaxKind.TemplateHead */:
+        case 16 /* SyntaxKind.TemplateMiddle */:
+        case 17 /* SyntaxKind.TemplateTail */:
+            tokenValue = rawTextScanner.getTokenValue();
+            break;
+    }
+    if (rawTextScanner.scan() !== 1 /* SyntaxKind.EndOfFileToken */) {
+        rawTextScanner.setText(undefined);
+        return invalidValueSentinel;
+    }
+    rawTextScanner.setText(undefined);
+    return tokenValue;
+}
+function createTemplateLiteralLikeNode(kind, text, rawText) {
+    const node = createSynthesizedNode(kind);
+    node.text = text;
+    if (rawText === undefined || text === rawText) {
+        node.rawText = rawText;
+    }
+    else {
+        const cooked = getCookedText(kind, rawText);
+        if (typeof cooked === "object") {
+            return Debug.fail("Invalid raw text");
+        }
+        Debug.assert(text === cooked, "Expected argument 'text' to be the normalized (i.e. 'cooked') version of argument 'rawText'.");
+        node.rawText = rawText;
+    }
+    return node;
+}
+export function createTemplateHead(text, rawText) {
+    const node = createTemplateLiteralLikeNode(15 /* SyntaxKind.TemplateHead */, text, rawText);
+    node.text = text;
+    return node;
+}
+export function createTemplateMiddle(text, rawText) {
+    const node = createTemplateLiteralLikeNode(16 /* SyntaxKind.TemplateMiddle */, text, rawText);
+    node.text = text;
+    return node;
+}
+export function createTemplateTail(text, rawText) {
+    const node = createTemplateLiteralLikeNode(17 /* SyntaxKind.TemplateTail */, text, rawText);
+    node.text = text;
+    return node;
+}
+export function createNoSubstitutionTemplateLiteral(text, rawText) {
+    const node = createTemplateLiteralLikeNode(14 /* SyntaxKind.NoSubstitutionTemplateLiteral */, text, rawText);
+    return node;
+}
+export function createSpread(expression) {
+    const node = createSynthesizedNode(213 /* SyntaxKind.SpreadElement */);
+    node.expression = parenthesizeExpressionForList(expression);
+    return node;
+}
+export function updateSpread(node, expression) {
+    return node.expression !== expression
+        ? updateNode(createSpread(expression), node)
+        : node;
+}
+export function createOmittedExpression() {
+    return createSynthesizedNode(215 /* SyntaxKind.OmittedExpression */);
+}
+export function createAsExpression(expression, type) {
+    const node = createSynthesizedNode(217 /* SyntaxKind.AsExpression */);
+    node.expression = expression;
+    node.type = type;
+    return node;
+}
+export function updateAsExpression(node, expression, type) {
+    return node.expression !== expression
+        || node.type !== type
+        ? updateNode(createAsExpression(expression, type), node)
+        : node;
+}
+export function createMetaProperty(keywordToken, name) {
+    const node = createSynthesizedNode(219 /* SyntaxKind.MetaProperty */);
+    node.keywordToken = keywordToken;
+    node.name = name;
+    return node;
+}
+export function updateMetaProperty(node, name) {
+    return node.name !== name
+        ? updateNode(createMetaProperty(node.keywordToken, name), node)
+        : node;
+}
+// Misc
+export function createTemplateSpan(expression, literal) {
+    const node = createSynthesizedNode(221 /* SyntaxKind.TemplateSpan */);
+    node.expression = expression;
+    node.literal = literal;
+    return node;
+}
+export function updateTemplateSpan(node, expression, literal) {
+    return node.expression !== expression
+        || node.literal !== literal
+        ? updateNode(createTemplateSpan(expression, literal), node)
+        : node;
+}
+// Element
+export function createBlock(statements, multiLine) {
+    const block = createSynthesizedNode(223 /* SyntaxKind.Block */);
+    block.statements = createNodeArray(statements);
+    if (multiLine)
+        block.multiLine = multiLine;
+    return block;
+}
+export function updateBlock(node, statements) {
+    return node.statements !== statements
+        ? updateNode(createBlock(statements, node.multiLine), node)
+        : node;
+}
+export function createVariableStatement(modifiers, declarationList) {
+    const node = createSynthesizedNode(225 /* SyntaxKind.VariableStatement */);
+    node.modifiers = asNodeArray(modifiers);
+    node.declarationList = isArray(declarationList) ? createVariableDeclarationList(declarationList) : declarationList;
+    return node;
+}
+export function updateVariableStatement(node, modifiers, declarationList) {
+    return node.modifiers !== modifiers
+        || node.declarationList !== declarationList
+        ? updateNode(createVariableStatement(modifiers, declarationList), node)
+        : node;
+}
+export function createEmptyStatement() {
+    return createSynthesizedNode(224 /* SyntaxKind.EmptyStatement */);
+}
+export function createExpressionStatement(expression) {
+    const node = createSynthesizedNode(226 /* SyntaxKind.ExpressionStatement */);
+    node.expression = parenthesizeExpressionForExpressionStatement(expression);
+    return node;
+}
+export function updateExpressionStatement(node, expression) {
+    return node.expression !== expression
+        ? updateNode(createExpressionStatement(expression), node)
+        : node;
+}
+/** @deprecated Use `createExpressionStatement` instead.  */
+export const createStatement = createExpressionStatement;
+export function createIf(expression, thenStatement, elseStatement) {
+    const node = createSynthesizedNode(227 /* SyntaxKind.IfStatement */);
+    node.expression = expression;
+    node.thenStatement = asEmbeddedStatement(thenStatement);
+    node.elseStatement = asEmbeddedStatement(elseStatement);
+    return node;
+}
+export function updateIf(node, expression, thenStatement, elseStatement) {
+    return node.expression !== expression
+        || node.thenStatement !== thenStatement
+        || node.elseStatement !== elseStatement
+        ? updateNode(createIf(expression, thenStatement, elseStatement), node)
+        : node;
+}
+export function createDo(statement, expression) {
+    const node = createSynthesizedNode(228 /* SyntaxKind.DoStatement */);
+    node.statement = asEmbeddedStatement(statement);
+    node.expression = expression;
+    return node;
+}
+export function updateDo(node, statement, expression) {
+    return node.statement !== statement
+        || node.expression !== expression
+        ? updateNode(createDo(statement, expression), node)
+        : node;
+}
+export function createWhile(expression, statement) {
+    const node = createSynthesizedNode(229 /* SyntaxKind.WhileStatement */);
+    node.expression = expression;
+    node.statement = asEmbeddedStatement(statement);
+    return node;
+}
+export function updateWhile(node, expression, statement) {
+    return node.expression !== expression
+        || node.statement !== statement
+        ? updateNode(createWhile(expression, statement), node)
+        : node;
+}
+export function createFor(initializer, condition, incrementor, statement) {
+    const node = createSynthesizedNode(230 /* SyntaxKind.ForStatement */);
+    node.initializer = initializer;
+    node.condition = condition;
+    node.incrementor = incrementor;
+    node.statement = asEmbeddedStatement(statement);
+    return node;
+}
+export function updateFor(node, initializer, condition, incrementor, statement) {
+    return node.initializer !== initializer
+        || node.condition !== condition
+        || node.incrementor !== incrementor
+        || node.statement !== statement
+        ? updateNode(createFor(initializer, condition, incrementor, statement), node)
+        : node;
+}
+export function createForIn(initializer, expression, statement) {
+    const node = createSynthesizedNode(231 /* SyntaxKind.ForInStatement */);
+    node.initializer = initializer;
+    node.expression = expression;
+    node.statement = asEmbeddedStatement(statement);
+    return node;
+}
+export function updateForIn(node, initializer, expression, statement) {
+    return node.initializer !== initializer
+        || node.expression !== expression
+        || node.statement !== statement
+        ? updateNode(createForIn(initializer, expression, statement), node)
+        : node;
+}
+export function createForOf(awaitModifier, initializer, expression, statement) {
+    const node = createSynthesizedNode(232 /* SyntaxKind.ForOfStatement */);
+    node.awaitModifier = awaitModifier;
+    node.initializer = initializer;
+    node.expression = isCommaSequence(expression) ? createParen(expression) : expression;
+    node.statement = asEmbeddedStatement(statement);
+    return node;
+}
+export function updateForOf(node, awaitModifier, initializer, expression, statement) {
+    return node.awaitModifier !== awaitModifier
+        || node.initializer !== initializer
+        || node.expression !== expression
+        || node.statement !== statement
+        ? updateNode(createForOf(awaitModifier, initializer, expression, statement), node)
+        : node;
+}
+export function createContinue() {
+    return createSynthesizedNode(233 /* SyntaxKind.ContinueStatement */);
+}
+export function createBreak() {
+    return createSynthesizedNode(234 /* SyntaxKind.BreakStatement */);
+}
+export function createReturn(expression) {
+    const node = createSynthesizedNode(235 /* SyntaxKind.ReturnStatement */);
+    node.expression = expression;
+    return node;
+}
+export function updateReturn(node, expression) {
+    return node.expression !== expression
+        ? updateNode(createReturn(expression), node)
+        : node;
+}
+export function createSwitch(expression, caseBlock) {
+    const node = createSynthesizedNode(237 /* SyntaxKind.SwitchStatement */);
+    node.expression = parenthesizeExpressionForList(expression);
+    node.caseBlock = caseBlock;
+    return node;
+}
+export function updateSwitch(node, expression, caseBlock) {
+    return node.expression !== expression
+        || node.caseBlock !== caseBlock
+        ? updateNode(createSwitch(expression, caseBlock), node)
+        : node;
+}
+export function createThrow(expression) {
+    const node = createSynthesizedNode(239 /* SyntaxKind.ThrowStatement */);
+    node.expression = expression;
+    return node;
+}
+export function updateThrow(node, expression) {
+    return node.expression !== expression
+        ? updateNode(createThrow(expression), node)
+        : node;
+}
+export function createTry(tryBlock, catchClause, finallyBlock) {
+    const node = createSynthesizedNode(240 /* SyntaxKind.TryStatement */);
+    node.tryBlock = tryBlock;
+    node.catchClause = catchClause;
+    node.finallyBlock = finallyBlock;
+    return node;
+}
+export function updateTry(node, tryBlock, catchClause, finallyBlock) {
+    return node.tryBlock !== tryBlock
+        || node.catchClause !== catchClause
+        || node.finallyBlock !== finallyBlock
+        ? updateNode(createTry(tryBlock, catchClause, finallyBlock), node)
+        : node;
+}
+export function createVariableDeclaration(name, type, initializer) {
+    /* Internally, one should probably use createTypeScriptVariableDeclaration instead and handle definite assignment assertions */
+    const node = createSynthesizedNode(242 /* SyntaxKind.VariableDeclaration */);
+    node.name = asName(name);
+    node.type = type;
+    node.initializer = initializer !== undefined ? parenthesizeExpressionForList(initializer) : undefined;
+    return node;
+}
+export function createTypeScriptVariableDeclaration(name, exclaimationToken, type, initializer) {
+    const node = createSynthesizedNode(242 /* SyntaxKind.VariableDeclaration */);
+    node.name = asName(name);
+    node.type = type;
+    node.initializer = initializer !== undefined ? parenthesizeExpressionForList(initializer) : undefined;
+    node.exclamationToken = exclaimationToken;
+    return node;
+}
+export function updateTypeScriptVariableDeclaration(node, name, exclaimationToken, type, initializer) {
+    return node.name !== name
+        || node.type !== type
+        || node.initializer !== initializer
+        || node.exclamationToken !== exclaimationToken
+        ? updateNode(createTypeScriptVariableDeclaration(name, exclaimationToken, type, initializer), node)
+        : node;
+}
+export function createVariableDeclarationList(declarations, flags = 0 /* NodeFlags.None */) {
+    const node = createSynthesizedNode(243 /* SyntaxKind.VariableDeclarationList */);
+    node.flags |= flags & 3 /* NodeFlags.BlockScoped */;
+    node.declarations = createNodeArray(declarations);
+    return node;
+}
+export function updateVariableDeclarationList(node, declarations) {
+    return node.declarations !== declarations
+        ? updateNode(createVariableDeclarationList(declarations, node.flags), node)
+        : node;
+}
+/** A função com outro corpo. Na tag, também a `function`, o método, o acessor e o construtor (CK-02). */
+export function updateFunctionLikeBody(declaration, body) {
+    switch (declaration.kind) {
+        case 202 /* SyntaxKind.ArrowFunction */:
+            return createArrowFunction(declaration.modifiers, declaration.typeParameters, declaration.parameters, declaration.type, declaration.equalsGreaterThanToken, body);
+    }
+}
+export function createTypeAliasDeclaration(modifiers, name, typeParameters, type) {
+    const node = createSynthesizedNode(247 /* SyntaxKind.TypeAliasDeclaration */);
+    node.modifiers = asNodeArray(modifiers);
+    node.name = asName(name);
+    node.typeParameters = asNodeArray(typeParameters);
+    node.type = type;
+    return node;
+}
+export function updateTypeAliasDeclaration(node, modifiers, name, typeParameters, type) {
+    return node.modifiers !== modifiers
+        || node.name !== name
+        || node.typeParameters !== typeParameters
+        || node.type !== type
+        ? updateNode(createTypeAliasDeclaration(modifiers, name, typeParameters, type), node)
+        : node;
+}
+export function createModuleDeclaration(modifiers, name, body, flags = 0 /* NodeFlags.None */) {
+    const node = createSynthesizedNode(249 /* SyntaxKind.ModuleDeclaration */);
+    node.flags |= flags & (16 /* NodeFlags.Namespace */ | 4 /* NodeFlags.NestedNamespace */ | 1024 /* NodeFlags.GlobalAugmentation */);
+    node.modifiers = asNodeArray(modifiers);
+    node.name = name;
+    node.body = body;
+    return node;
+}
+export function updateModuleDeclaration(node, modifiers, name, body) {
+    return node.modifiers !== modifiers
+        || node.name !== name
+        || node.body !== body
+        ? updateNode(createModuleDeclaration(modifiers, name, body, node.flags), node)
+        : node;
+}
+export function createModuleBlock(statements) {
+    const node = createSynthesizedNode(250 /* SyntaxKind.ModuleBlock */);
+    node.statements = createNodeArray(statements);
+    return node;
+}
+export function updateModuleBlock(node, statements) {
+    return node.statements !== statements
+        ? updateNode(createModuleBlock(statements), node)
+        : node;
+}
+export function createCaseBlock(clauses) {
+    const node = createSynthesizedNode(251 /* SyntaxKind.CaseBlock */);
+    node.clauses = createNodeArray(clauses);
+    return node;
+}
+export function updateCaseBlock(node, clauses) {
+    return node.clauses !== clauses
+        ? updateNode(createCaseBlock(clauses), node)
+        : node;
+}
+export function createImportDeclaration(modifiers, importClause, moduleSpecifier) {
+    const node = createSynthesizedNode(254 /* SyntaxKind.ImportDeclaration */);
+    node.modifiers = asNodeArray(modifiers);
+    node.importClause = importClause;
+    node.moduleSpecifier = moduleSpecifier;
+    return node;
+}
+export function updateImportDeclaration(node, modifiers, importClause, moduleSpecifier) {
+    return node.modifiers !== modifiers
+        || node.importClause !== importClause
+        || node.moduleSpecifier !== moduleSpecifier
+        ? updateNode(createImportDeclaration(modifiers, importClause, moduleSpecifier), node)
+        : node;
+}
+export function createImportClause(name, namedBindings, isTypeOnly = false) {
+    const node = createSynthesizedNode(255 /* SyntaxKind.ImportClause */);
+    node.name = name;
+    node.namedBindings = namedBindings;
+    node.isTypeOnly = isTypeOnly;
+    return node;
+}
+export function updateImportClause(node, name, namedBindings, isTypeOnly) {
+    return node.name !== name
+        || node.namedBindings !== namedBindings
+        || node.isTypeOnly !== isTypeOnly
+        ? updateNode(createImportClause(name, namedBindings, isTypeOnly), node)
+        : node;
+}
+export function createNamespaceImport(name) {
+    const node = createSynthesizedNode(256 /* SyntaxKind.NamespaceImport */);
+    node.name = name;
+    return node;
+}
+export function createNamespaceExport(name) {
+    const node = createSynthesizedNode(262 /* SyntaxKind.NamespaceExport */);
+    node.name = name;
+    return node;
+}
+export function updateNamespaceImport(node, name) {
+    return node.name !== name
+        ? updateNode(createNamespaceImport(name), node)
+        : node;
+}
+export function updateNamespaceExport(node, name) {
+    return node.name !== name
+        ? updateNode(createNamespaceExport(name), node)
+        : node;
+}
+export function createNamedImports(elements) {
+    const node = createSynthesizedNode(257 /* SyntaxKind.NamedImports */);
+    node.elements = createNodeArray(elements);
+    return node;
+}
+export function updateNamedImports(node, elements) {
+    return node.elements !== elements
+        ? updateNode(createNamedImports(elements), node)
+        : node;
+}
+export function createImportSpecifier(propertyName, name) {
+    const node = createSynthesizedNode(258 /* SyntaxKind.ImportSpecifier */);
+    node.propertyName = propertyName;
+    node.name = name;
+    return node;
+}
+export function updateImportSpecifier(node, propertyName, name) {
+    return node.propertyName !== propertyName
+        || node.name !== name
+        ? updateNode(createImportSpecifier(propertyName, name), node)
+        : node;
+}
+export function createExportAssignment(modifiers, expression) {
+    const node = createSynthesizedNode(259 /* SyntaxKind.ExportAssignment */);
+    node.modifiers = asNodeArray(modifiers);
+    node.expression = parenthesizeDefaultExpression(expression);
+    return node;
+}
+export function updateExportAssignment(node, modifiers, expression) {
+    return node.modifiers !== modifiers
+        || node.expression !== expression
+        ? updateNode(createExportAssignment(modifiers, expression), node)
+        : node;
+}
+export function createExportDeclaration(modifiers, exportClause, moduleSpecifier, isTypeOnly = false) {
+    const node = createSynthesizedNode(260 /* SyntaxKind.ExportDeclaration */);
+    node.modifiers = asNodeArray(modifiers);
+    node.isTypeOnly = isTypeOnly;
+    node.exportClause = exportClause;
+    node.moduleSpecifier = moduleSpecifier;
+    return node;
+}
+export function updateExportDeclaration(node, modifiers, exportClause, moduleSpecifier, isTypeOnly) {
+    return node.modifiers !== modifiers
+        || node.isTypeOnly !== isTypeOnly
+        || node.exportClause !== exportClause
+        || node.moduleSpecifier !== moduleSpecifier
+        ? updateNode(createExportDeclaration(modifiers, exportClause, moduleSpecifier, isTypeOnly), node)
+        : node;
+}
+export function createNamedExports(elements) {
+    const node = createSynthesizedNode(261 /* SyntaxKind.NamedExports */);
+    node.elements = createNodeArray(elements);
+    return node;
+}
+export function updateNamedExports(node, elements) {
+    return node.elements !== elements
+        ? updateNode(createNamedExports(elements), node)
+        : node;
+}
+export function createExportSpecifier(propertyName, name) {
+    const node = createSynthesizedNode(263 /* SyntaxKind.ExportSpecifier */);
+    node.propertyName = asName(propertyName);
+    node.name = asName(name);
+    return node;
+}
+export function updateExportSpecifier(node, propertyName, name) {
+    return node.propertyName !== propertyName
+        || node.name !== name
+        ? updateNode(createExportSpecifier(propertyName, name), node)
+        : node;
+}
+// JSX
+export function createJsxElement(openingElement, children, closingElement) {
+    const node = createSynthesizedNode(266 /* SyntaxKind.JsxElement */);
+    node.openingElement = openingElement;
+    node.children = createNodeArray(children);
+    node.closingElement = closingElement;
+    return node;
+}
+export function updateJsxElement(node, openingElement, children, closingElement) {
+    return node.openingElement !== openingElement
+        || node.children !== children
+        || node.closingElement !== closingElement
+        ? updateNode(createJsxElement(openingElement, children, closingElement), node)
+        : node;
+}
+export function createJsxSelfClosingElement(tagName, typeArguments, attributes) {
+    const node = createSynthesizedNode(267 /* SyntaxKind.JsxSelfClosingElement */);
+    node.tagName = tagName;
+    node.typeArguments = asNodeArray(typeArguments);
+    node.attributes = attributes;
+    return node;
+}
+export function updateJsxSelfClosingElement(node, tagName, typeArguments, attributes) {
+    return node.tagName !== tagName
+        || node.typeArguments !== typeArguments
+        || node.attributes !== attributes
+        ? updateNode(createJsxSelfClosingElement(tagName, typeArguments, attributes), node)
+        : node;
+}
+export function createJsxOpeningElement(tagName, typeArguments, attributes) {
+    const node = createSynthesizedNode(268 /* SyntaxKind.JsxOpeningElement */);
+    node.tagName = tagName;
+    node.typeArguments = asNodeArray(typeArguments);
+    node.attributes = attributes;
+    return node;
+}
+export function updateJsxOpeningElement(node, tagName, typeArguments, attributes) {
+    return node.tagName !== tagName
+        || node.typeArguments !== typeArguments
+        || node.attributes !== attributes
+        ? updateNode(createJsxOpeningElement(tagName, typeArguments, attributes), node)
+        : node;
+}
+export function createJsxClosingElement(tagName) {
+    const node = createSynthesizedNode(269 /* SyntaxKind.JsxClosingElement */);
+    node.tagName = tagName;
+    return node;
+}
+export function updateJsxClosingElement(node, tagName) {
+    return node.tagName !== tagName
+        ? updateNode(createJsxClosingElement(tagName), node)
+        : node;
+}
+export function createJsxFragment(openingFragment, children, closingFragment) {
+    const node = createSynthesizedNode(270 /* SyntaxKind.JsxFragment */);
+    node.openingFragment = openingFragment;
+    node.children = createNodeArray(children);
+    node.closingFragment = closingFragment;
+    return node;
+}
+export function createJsxText(text, containsOnlyTriviaWhiteSpaces) {
+    const node = createSynthesizedNode(11 /* SyntaxKind.JsxText */);
+    node.text = text;
+    node.containsOnlyTriviaWhiteSpaces = !!containsOnlyTriviaWhiteSpaces;
+    return node;
+}
+export function createJsxOpeningFragment() {
+    return createSynthesizedNode(271 /* SyntaxKind.JsxOpeningFragment */);
+}
+export function createJsxJsxClosingFragment() {
+    return createSynthesizedNode(272 /* SyntaxKind.JsxClosingFragment */);
+}
+export function updateJsxFragment(node, openingFragment, children, closingFragment) {
+    return node.openingFragment !== openingFragment
+        || node.children !== children
+        || node.closingFragment !== closingFragment
+        ? updateNode(createJsxFragment(openingFragment, children, closingFragment), node)
+        : node;
+}
+export function createJsxAttribute(name, initializer) {
+    const node = createSynthesizedNode(273 /* SyntaxKind.JsxAttribute */);
+    node.name = name;
+    node.initializer = initializer;
+    return node;
+}
+export function updateJsxAttribute(node, name, initializer) {
+    return node.name !== name
+        || node.initializer !== initializer
+        ? updateNode(createJsxAttribute(name, initializer), node)
+        : node;
+}
+export function createJsxAttributes(properties) {
+    const node = createSynthesizedNode(274 /* SyntaxKind.JsxAttributes */);
+    node.properties = createNodeArray(properties);
+    return node;
+}
+export function updateJsxAttributes(node, properties) {
+    return node.properties !== properties
+        ? updateNode(createJsxAttributes(properties), node)
+        : node;
+}
+export function createJsxSpreadAttribute(expression) {
+    const node = createSynthesizedNode(275 /* SyntaxKind.JsxSpreadAttribute */);
+    node.expression = expression;
+    return node;
+}
+export function updateJsxSpreadAttribute(node, expression) {
+    return node.expression !== expression
+        ? updateNode(createJsxSpreadAttribute(expression), node)
+        : node;
+}
+export function createJsxExpression(dotDotDotToken, expression) {
+    const node = createSynthesizedNode(276 /* SyntaxKind.JsxExpression */);
+    node.dotDotDotToken = dotDotDotToken;
+    node.expression = expression;
+    return node;
+}
+export function updateJsxExpression(node, expression) {
+    return node.expression !== expression
+        ? updateNode(createJsxExpression(node.dotDotDotToken, expression), node)
+        : node;
+}
+// Clauses
+export function createCaseClause(expression, statements) {
+    const node = createSynthesizedNode(277 /* SyntaxKind.CaseClause */);
+    node.expression = parenthesizeExpressionForList(expression);
+    node.statements = createNodeArray(statements);
+    return node;
+}
+export function updateCaseClause(node, expression, statements) {
+    return node.expression !== expression
+        || node.statements !== statements
+        ? updateNode(createCaseClause(expression, statements), node)
+        : node;
+}
+export function createDefaultClause(statements) {
+    const node = createSynthesizedNode(278 /* SyntaxKind.DefaultClause */);
+    node.statements = createNodeArray(statements);
+    return node;
+}
+export function updateDefaultClause(node, statements) {
+    return node.statements !== statements
+        ? updateNode(createDefaultClause(statements), node)
+        : node;
+}
+export function createCatchClause(variableDeclaration, block) {
+    const node = createSynthesizedNode(280 /* SyntaxKind.CatchClause */);
+    node.variableDeclaration = isString(variableDeclaration) ? createVariableDeclaration(variableDeclaration) : variableDeclaration;
+    node.block = block;
+    return node;
+}
+export function updateCatchClause(node, variableDeclaration, block) {
+    return node.variableDeclaration !== variableDeclaration
+        || node.block !== block
+        ? updateNode(createCatchClause(variableDeclaration, block), node)
+        : node;
+}
+// Property assignments
+export function createPropertyAssignment(name, initializer) {
+    const node = createSynthesizedNode(281 /* SyntaxKind.PropertyAssignment */);
+    node.name = asName(name);
+    node.questionToken = undefined;
+    node.initializer = parenthesizeExpressionForList(initializer);
+    return node;
+}
+export function updatePropertyAssignment(node, name, initializer) {
+    return node.name !== name
+        || node.initializer !== initializer
+        ? updateNode(createPropertyAssignment(name, initializer), node)
+        : node;
+}
+export function createShorthandPropertyAssignment(name, objectAssignmentInitializer) {
+    const node = createSynthesizedNode(282 /* SyntaxKind.ShorthandPropertyAssignment */);
+    node.name = asName(name);
+    node.objectAssignmentInitializer = objectAssignmentInitializer !== undefined ? parenthesizeExpressionForList(objectAssignmentInitializer) : undefined;
+    return node;
+}
+export function updateShorthandPropertyAssignment(node, name, objectAssignmentInitializer) {
+    return node.name !== name
+        || node.objectAssignmentInitializer !== objectAssignmentInitializer
+        ? updateNode(createShorthandPropertyAssignment(name, objectAssignmentInitializer), node)
+        : node;
+}
+export function createSpreadAssignment(expression) {
+    const node = createSynthesizedNode(283 /* SyntaxKind.SpreadAssignment */);
+    node.expression = parenthesizeExpressionForList(expression);
+    return node;
+}
+export function updateSpreadAssignment(node, expression) {
+    return node.expression !== expression
+        ? updateNode(createSpreadAssignment(expression), node)
+        : node;
+}
+// Top-level nodes
+export function updateSourceFileNode(node, statements, isDeclarationFile, referencedFiles, typeReferences, hasNoDefaultLib, libReferences) {
+    if (node.statements !== statements ||
+        (isDeclarationFile !== undefined && node.isDeclarationFile !== isDeclarationFile) ||
+        (referencedFiles !== undefined && node.referencedFiles !== referencedFiles) ||
+        (typeReferences !== undefined && node.typeReferenceDirectives !== typeReferences) ||
+        (libReferences !== undefined && node.libReferenceDirectives !== libReferences) ||
+        (hasNoDefaultLib !== undefined && node.hasNoDefaultLib !== hasNoDefaultLib)) {
+        const updated = createSynthesizedNode(290 /* SyntaxKind.SourceFile */);
+        updated.flags |= node.flags;
+        updated.statements = createNodeArray(statements);
+        updated.endOfFileToken = node.endOfFileToken;
+        updated.fileName = node.fileName;
+        updated.path = node.path;
+        updated.text = node.text;
+        updated.isDeclarationFile = isDeclarationFile === undefined ? node.isDeclarationFile : isDeclarationFile;
+        updated.referencedFiles = referencedFiles === undefined ? node.referencedFiles : referencedFiles;
+        updated.typeReferenceDirectives = typeReferences === undefined ? node.typeReferenceDirectives : typeReferences;
+        updated.hasNoDefaultLib = hasNoDefaultLib === undefined ? node.hasNoDefaultLib : hasNoDefaultLib;
+        updated.libReferenceDirectives = libReferences === undefined ? node.libReferenceDirectives : libReferences;
+        if (node.amdDependencies !== undefined)
+            updated.amdDependencies = node.amdDependencies;
+        if (node.moduleName !== undefined)
+            updated.moduleName = node.moduleName;
+        if (node.languageVariant !== undefined)
+            updated.languageVariant = node.languageVariant;
+        if (node.renamedDependencies !== undefined)
+            updated.renamedDependencies = node.renamedDependencies;
+        if (node.languageVersion !== undefined)
+            updated.languageVersion = node.languageVersion;
+        if (node.scriptKind !== undefined)
+            updated.scriptKind = node.scriptKind;
+        if (node.externalModuleIndicator !== undefined)
+            updated.externalModuleIndicator = node.externalModuleIndicator;
+        if (node.commonJsModuleIndicator !== undefined)
+            updated.commonJsModuleIndicator = node.commonJsModuleIndicator;
+        if (node.identifiers !== undefined)
+            updated.identifiers = node.identifiers;
+        if (node.parseDiagnostics !== undefined)
+            updated.parseDiagnostics = node.parseDiagnostics;
+        if (node.bindDiagnostics !== undefined)
+            updated.bindDiagnostics = node.bindDiagnostics;
+        if (node.bindSuggestionDiagnostics !== undefined)
+            updated.bindSuggestionDiagnostics = node.bindSuggestionDiagnostics;
+        if (node.lineMap !== undefined)
+            updated.lineMap = node.lineMap;
+        if (node.resolvedModules !== undefined)
+            updated.resolvedModules = node.resolvedModules;
+        if (node.imports !== undefined)
+            updated.imports = node.imports;
+        if (node.moduleAugmentations !== undefined)
+            updated.moduleAugmentations = node.moduleAugmentations;
+        if (node.pragmas !== undefined)
+            updated.pragmas = node.pragmas;
+        return updateNode(updated, node);
+    }
+    return node;
+}
+/**
+ * Creates a shallow, memberwise clone of a node for mutation.
+ */
+export function getMutableClone(node) {
+    const clone = getSynthesizedClone(node);
+    clone.pos = node.pos;
+    clone.end = node.end;
+    clone.parent = node.parent;
+    return clone;
+}
+// Transformation nodes
+/**
+ * Creates a synthetic expression to act as a placeholder for a not-emitted expression in
+ * order to preserve comments or sourcemap positions.
+ *
+ * @param expression The inner expression to emit.
+ * @param original The original outer expression.
+ * @param location The location for the expression. Defaults to the positions from "original" if provided.
+ */
+export function createPartiallyEmittedExpression(expression, original) {
+    const node = createSynthesizedNode(326 /* SyntaxKind.PartiallyEmittedExpression */);
+    node.expression = expression;
+    node.original = original;
+    setTextRange(node, original);
+    return node;
+}
+export function updatePartiallyEmittedExpression(node, expression) {
+    if (node.expression !== expression) {
+        return updateNode(createPartiallyEmittedExpression(expression, node.original), node);
+    }
+    return node;
+}
+function flattenCommaElements(node) {
+    if (nodeIsSynthesized(node) && !isParseTreeNode(node) && !node.original && !node.emitNode && !node.id) {
+        if (node.kind === 327 /* SyntaxKind.CommaListExpression */) {
+            return node.elements;
+        }
+        if (isBinaryExpression(node) && node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) {
+            return [node.left, node.right];
+        }
+    }
+    return node;
+}
+export function createCommaList(elements) {
+    const node = createSynthesizedNode(327 /* SyntaxKind.CommaListExpression */);
+    node.elements = createNodeArray(sameFlatMap(elements, flattenCommaElements));
+    return node;
+}
+export function updateCommaList(node, elements) {
+    return node.elements !== elements
+        ? updateNode(createCommaList(elements), node)
+        : node;
+}
+export function createBundle(sourceFiles, prepends = emptyArray) {
+    const node = createNode(291 /* SyntaxKind.Bundle */);
+    node.prepends = prepends;
+    node.sourceFiles = sourceFiles;
+    return node;
+}
+export function createAssignment(left, right) {
+    return createBinary(left, 62 /* SyntaxKind.EqualsToken */, right);
+}
+export function createExportDefault(expression) {
+    return createExportAssignment(/*modifiers*/ undefined, expression);
+}
+// Utilities
+function asName(name) {
+    return isString(name) ? createIdentifier(name) : name;
+}
+function asExpression(value) {
+    return typeof value === "string" ? createStringLiteral(value) :
+        typeof value === "number" ? createNumericLiteral("" + value) :
+            typeof value === "boolean" ? value ? createTrue() : createFalse() :
+                value;
+}
+function asNodeArray(array) {
+    return array ? createNodeArray(array) : undefined;
+}
+function asToken(value) {
+    return typeof value === "number" ? createToken(value) : value;
+}
+function asEmbeddedStatement(statement) {
+    return statement && isNotEmittedStatement(statement) ? setTextRange(setOriginalNode(createEmptyStatement(), statement), statement) : statement;
+}
+/**
+ * Associates a node with the current transformation, initializing
+ * various transient transformation properties.
+ */
+export function getOrCreateEmitNode(node) {
+    if (!node.emitNode) {
+        if (isParseTreeNode(node)) {
+            // To avoid holding onto transformation artifacts, we keep track of any
+            // parse tree node we are annotating. This allows us to clean them up after
+            // all transformations have completed.
+            if (node.kind === 290 /* SyntaxKind.SourceFile */) {
+                return node.emitNode = { annotatedNodes: [node] };
+            }
+            const sourceFile = getSourceFileOfNode(getParseTreeNode(getSourceFileOfNode(node)));
+            getOrCreateEmitNode(sourceFile).annotatedNodes.push(node);
+        }
+        node.emitNode = {};
+    }
+    return node.emitNode;
+}
+export function setTextRange(range, location) {
+    if (location) {
+        range.pos = location.pos;
+        range.end = location.end;
+    }
+    return range;
+}
+/**
+ * Sets flags that control emit behavior of a node.
+ */
+export function setEmitFlags(node, emitFlags) {
+    getOrCreateEmitNode(node).flags = emitFlags;
+    return node;
+}
+/**
+ * Sets flags that control emit behavior of a node.
+ */
+export function addEmitFlags(node, emitFlags) {
+    const emitNode = getOrCreateEmitNode(node);
+    emitNode.flags = emitNode.flags | emitFlags;
+    return node;
+}
+/**
+ * Gets a custom text range to use when emitting source maps.
+ */
+export function getSourceMapRange(node) {
+    const emitNode = node.emitNode;
+    return (emitNode && emitNode.sourceMapRange) || node;
+}
+let SourceMapSource;
+/**
+ * Gets a custom text range to use when emitting comments.
+ */
+export function getStartsOnNewLine(node) {
+    const emitNode = node.emitNode;
+    return emitNode && emitNode.startsOnNewLine;
+}
+/**
+ * Sets a custom text range to use when emitting comments.
+ */
+export function setStartsOnNewLine(node, newLine) {
+    getOrCreateEmitNode(node).startsOnNewLine = newLine;
+    return node;
+}
+/**
+ * Gets a custom text range to use when emitting comments.
+ */
+export function getCommentRange(node) {
+    const emitNode = node.emitNode;
+    return (emitNode && emitNode.commentRange) || node;
+}
+/**
+ * Sets a custom text range to use when emitting comments.
+ */
+export function setCommentRange(node, range) {
+    getOrCreateEmitNode(node).commentRange = range;
+    return node;
+}
+export function getSyntheticLeadingComments(node) {
+    const emitNode = node.emitNode;
+    return emitNode && emitNode.leadingComments;
+}
+export function setSyntheticLeadingComments(node, comments) {
+    getOrCreateEmitNode(node).leadingComments = comments;
+    return node;
+}
+export function addSyntheticLeadingComment(node, kind, text, hasTrailingNewLine) {
+    return setSyntheticLeadingComments(node, append(getSyntheticLeadingComments(node), { kind, pos: -1, end: -1, hasTrailingNewLine, text }));
+}
+export function getSyntheticTrailingComments(node) {
+    const emitNode = node.emitNode;
+    return emitNode && emitNode.trailingComments;
+}
+export function setSyntheticTrailingComments(node, comments) {
+    getOrCreateEmitNode(node).trailingComments = comments;
+    return node;
+}
+export function addSyntheticTrailingComment(node, kind, text, hasTrailingNewLine) {
+    return setSyntheticTrailingComments(node, append(getSyntheticTrailingComments(node), { kind, pos: -1, end: -1, hasTrailingNewLine, text }));
+}
+export function ignoreSourceNewlines(node) {
+    getOrCreateEmitNode(node).flags |= 134217728 /* EmitFlags.IgnoreSourceNewlines */;
+    return node;
+}
+/**
+ * Gets the EmitHelpers of a node.
+ */
+export function getEmitHelpers(node) {
+    const emitNode = node.emitNode;
+    return emitNode && emitNode.helpers;
+}
+export function setOriginalNode(node, original) {
+    node.original = original;
+    if (original) {
+        const emitNode = original.emitNode;
+        if (emitNode)
+            node.emitNode = mergeEmitNode(emitNode, node.emitNode);
+    }
+    return node;
+}
+function mergeEmitNode(sourceEmitNode, destEmitNode) {
+    const { flags, leadingComments, trailingComments, commentRange, sourceMapRange, tokenSourceMapRanges, helpers, startsOnNewLine, } = sourceEmitNode;
+    if (!destEmitNode)
+        destEmitNode = {};
+    // We are using `.slice()` here in case `destEmitNode.leadingComments` is pushed to later.
+    if (leadingComments)
+        destEmitNode.leadingComments = addRange(leadingComments.slice(), destEmitNode.leadingComments);
+    if (trailingComments)
+        destEmitNode.trailingComments = addRange(trailingComments.slice(), destEmitNode.trailingComments);
+    if (flags)
+        destEmitNode.flags = flags;
+    if (commentRange)
+        destEmitNode.commentRange = commentRange;
+    if (sourceMapRange)
+        destEmitNode.sourceMapRange = sourceMapRange;
+    if (tokenSourceMapRanges)
+        destEmitNode.tokenSourceMapRanges = mergeTokenSourceMapRanges(tokenSourceMapRanges, destEmitNode.tokenSourceMapRanges);
+    if (helpers)
+        destEmitNode.helpers = addRange(destEmitNode.helpers, helpers);
+    if (startsOnNewLine !== undefined)
+        destEmitNode.startsOnNewLine = startsOnNewLine;
+    return destEmitNode;
+}
+function mergeTokenSourceMapRanges(sourceRanges, destRanges) {
+    if (!destRanges)
+        destRanges = [];
+    for (const key in sourceRanges) {
+        destRanges[key] = sourceRanges[key];
+    }
+    return destRanges;
+}