“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.TSTypeAnnotation = TSTypeAnnotation; exports.TSTypeParameterDeclaration = exports.TSTypeParameterInstantiation = TSTypeParameterInstantiation; exports.TSTypeParameter = TSTypeParameter; exports.TSParameterProperty = TSParameterProperty; exports.TSDeclareFunction = TSDeclareFunction; exports.TSDeclareMethod = TSDeclareMethod; exports.TSQualifiedName = TSQualifiedName; exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration; exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration; exports.TSPropertySignature = TSPropertySignature; exports.tsPrintPropertyOrMethodName = tsPrintPropertyOrMethodName; exports.TSMethodSignature = TSMethodSignature; exports.TSIndexSignature = TSIndexSignature; exports.TSAnyKeyword = TSAnyKeyword; exports.TSBigIntKeyword = TSBigIntKeyword; exports.TSUnknownKeyword = TSUnknownKeyword; exports.TSNumberKeyword = TSNumberKeyword; exports.TSObjectKeyword = TSObjectKeyword; exports.TSBooleanKeyword = TSBooleanKeyword; exports.TSStringKeyword = TSStringKeyword; exports.TSSymbolKeyword = TSSymbolKeyword; exports.TSVoidKeyword = TSVoidKeyword; exports.TSUndefinedKeyword = TSUndefinedKeyword; exports.TSNullKeyword = TSNullKeyword; exports.TSNeverKeyword = TSNeverKeyword; exports.TSThisType = TSThisType; exports.TSFunctionType = TSFunctionType; exports.TSConstructorType = TSConstructorType; exports.tsPrintFunctionOrConstructorType = tsPrintFunctionOrConstructorType; exports.TSTypeReference = TSTypeReference; exports.TSTypePredicate = TSTypePredicate; exports.TSTypeQuery = TSTypeQuery; exports.TSTypeLiteral = TSTypeLiteral; exports.tsPrintTypeLiteralOrInterfaceBody = tsPrintTypeLiteralOrInterfaceBody; exports.tsPrintBraced = tsPrintBraced; exports.TSArrayType = TSArrayType; exports.TSTupleType = TSTupleType; exports.TSOptionalType = TSOptionalType; exports.TSRestType = TSRestType; exports.TSUnionType = TSUnionType; exports.TSIntersectionType = TSIntersectionType; exports.tsPrintUnionOrIntersectionType = tsPrintUnionOrIntersectionType; exports.TSConditionalType = TSConditionalType; exports.TSInferType = TSInferType; exports.TSParenthesizedType = TSParenthesizedType; exports.TSTypeOperator = TSTypeOperator; exports.TSIndexedAccessType = TSIndexedAccessType; exports.TSMappedType = TSMappedType; exports.TSLiteralType = TSLiteralType; exports.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments; exports.TSInterfaceDeclaration = TSInterfaceDeclaration; exports.TSInterfaceBody = TSInterfaceBody; exports.TSTypeAliasDeclaration = TSTypeAliasDeclaration; exports.TSAsExpression = TSAsExpression; exports.TSTypeAssertion = TSTypeAssertion; exports.TSEnumDeclaration = TSEnumDeclaration; exports.TSEnumMember = TSEnumMember; exports.TSModuleDeclaration = TSModuleDeclaration; exports.TSModuleBlock = TSModuleBlock; exports.TSImportType = TSImportType; exports.TSImportEqualsDeclaration = TSImportEqualsDeclaration; exports.TSExternalModuleReference = TSExternalModuleReference; exports.TSNonNullExpression = TSNonNullExpression; exports.TSExportAssignment = TSExportAssignment; exports.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration; exports.tsPrintSignatureDeclarationBase = tsPrintSignatureDeclarationBase;

function TSTypeAnnotation(node) {

this.token(":");
this.space();
if (node.optional) this.token("?");
this.print(node.typeAnnotation, node);

}

function TSTypeParameterInstantiation(node) {

this.token("<");
this.printList(node.params, node, {});
this.token(">");

}

function TSTypeParameter(node) {

this.word(node.name);

if (node.constraint) {
  this.space();
  this.word("extends");
  this.space();
  this.print(node.constraint, node);
}

if (node.default) {
  this.space();
  this.token("=");
  this.space();
  this.print(node.default, node);
}

}

function TSParameterProperty(node) {

if (node.accessibility) {
  this.word(node.accessibility);
  this.space();
}

if (node.readonly) {
  this.word("readonly");
  this.space();
}

this._param(node.parameter);

}

function TSDeclareFunction(node) {

if (node.declare) {
  this.word("declare");
  this.space();
}

this._functionHead(node);

this.token(";");

}

function TSDeclareMethod(node) {

this._classMethodHead(node);

this.token(";");

}

function TSQualifiedName(node) {

this.print(node.left, node);
this.token(".");
this.print(node.right, node);

}

function TSCallSignatureDeclaration(node) {

this.tsPrintSignatureDeclarationBase(node);
this.token(";");

}

function TSConstructSignatureDeclaration(node) {

this.word("new");
this.space();
this.tsPrintSignatureDeclarationBase(node);
this.token(";");

}

function TSPropertySignature(node) {

const {
  readonly,
  initializer
} = node;

if (readonly) {
  this.word("readonly");
  this.space();
}

this.tsPrintPropertyOrMethodName(node);
this.print(node.typeAnnotation, node);

if (initializer) {
  this.space();
  this.token("=");
  this.space();
  this.print(initializer, node);
}

this.token(";");

}

function tsPrintPropertyOrMethodName(node) {

if (node.computed) {
  this.token("[");
}

this.print(node.key, node);

if (node.computed) {
  this.token("]");
}

if (node.optional) {
  this.token("?");
}

}

function TSMethodSignature(node) {

this.tsPrintPropertyOrMethodName(node);
this.tsPrintSignatureDeclarationBase(node);
this.token(";");

}

function TSIndexSignature(node) {

const {
  readonly
} = node;

if (readonly) {
  this.word("readonly");
  this.space();
}

this.token("[");

this._parameters(node.parameters, node);

this.token("]");
this.print(node.typeAnnotation, node);
this.token(";");

}

function TSAnyKeyword() {

this.word("any");

}

function TSBigIntKeyword() {

this.word("bigint");

}

function TSUnknownKeyword() {

this.word("unknown");

}

function TSNumberKeyword() {

this.word("number");

}

function TSObjectKeyword() {

this.word("object");

}

function TSBooleanKeyword() {

this.word("boolean");

}

function TSStringKeyword() {

this.word("string");

}

function TSSymbolKeyword() {

this.word("symbol");

}

function TSVoidKeyword() {

this.word("void");

}

function TSUndefinedKeyword() {

this.word("undefined");

}

function TSNullKeyword() {

this.word("null");

}

function TSNeverKeyword() {

this.word("never");

}

function TSThisType() {

this.word("this");

}

function TSFunctionType(node) {

this.tsPrintFunctionOrConstructorType(node);

}

function TSConstructorType(node) {

this.word("new");
this.space();
this.tsPrintFunctionOrConstructorType(node);

}

function tsPrintFunctionOrConstructorType(node) {

const {
  typeParameters,
  parameters
} = node;
this.print(typeParameters, node);
this.token("(");

this._parameters(parameters, node);

this.token(")");
this.space();
this.token("=>");
this.space();
this.print(node.typeAnnotation.typeAnnotation, node);

}

function TSTypeReference(node) {

this.print(node.typeName, node);
this.print(node.typeParameters, node);

}

function TSTypePredicate(node) {

this.print(node.parameterName);
this.space();
this.word("is");
this.space();
this.print(node.typeAnnotation.typeAnnotation);

}

function TSTypeQuery(node) {

this.word("typeof");
this.space();
this.print(node.exprName);

}

function TSTypeLiteral(node) {

this.tsPrintTypeLiteralOrInterfaceBody(node.members, node);

}

function tsPrintTypeLiteralOrInterfaceBody(members, node) {

this.tsPrintBraced(members, node);

}

function tsPrintBraced(members, node) {

this.token("{");

if (members.length) {
  this.indent();
  this.newline();

  for (const member of members) {
    this.print(member, node);
    this.newline();
  }

  this.dedent();
  this.rightBrace();
} else {
  this.token("}");
}

}

function TSArrayType(node) {

this.print(node.elementType, node);
this.token("[]");

}

function TSTupleType(node) {

this.token("[");
this.printList(node.elementTypes, node);
this.token("]");

}

function TSOptionalType(node) {

this.print(node.typeAnnotation, node);
this.token("?");

}

function TSRestType(node) {

this.token("...");
this.print(node.typeAnnotation, node);

}

function TSUnionType(node) {

this.tsPrintUnionOrIntersectionType(node, "|");

}

function TSIntersectionType(node) {

this.tsPrintUnionOrIntersectionType(node, "&");

}

function tsPrintUnionOrIntersectionType(node, sep) {

this.printJoin(node.types, node, {
  separator() {
    this.space();
    this.token(sep);
    this.space();
  }

});

}

function TSConditionalType(node) {

this.print(node.checkType);
this.space();
this.word("extends");
this.space();
this.print(node.extendsType);
this.space();
this.token("?");
this.space();
this.print(node.trueType);
this.space();
this.token(":");
this.space();
this.print(node.falseType);

}

function TSInferType(node) {

this.token("infer");
this.space();
this.print(node.typeParameter);

}

function TSParenthesizedType(node) {

this.token("(");
this.print(node.typeAnnotation, node);
this.token(")");

}

function TSTypeOperator(node) {

this.token(node.operator);
this.space();
this.print(node.typeAnnotation, node);

}

function TSIndexedAccessType(node) {

this.print(node.objectType, node);
this.token("[");
this.print(node.indexType, node);
this.token("]");

}

function TSMappedType(node) {

const {
  readonly,
  typeParameter,
  optional
} = node;
this.token("{");
this.space();

if (readonly) {
  tokenIfPlusMinus(this, readonly);
  this.word("readonly");
  this.space();
}

this.token("[");
this.word(typeParameter.name);
this.space();
this.word("in");
this.space();
this.print(typeParameter.constraint, typeParameter);
this.token("]");

if (optional) {
  tokenIfPlusMinus(this, optional);
  this.token("?");
}

this.token(":");
this.space();
this.print(node.typeAnnotation, node);
this.space();
this.token("}");

}

function tokenIfPlusMinus(self, tok) {

if (tok !== true) {
  self.token(tok);
}

}

function TSLiteralType(node) {

this.print(node.literal, node);

}

function TSExpressionWithTypeArguments(node) {

this.print(node.expression, node);
this.print(node.typeParameters, node);

}

function TSInterfaceDeclaration(node) {

const {
  declare,
  id,
  typeParameters,
  extends: extendz,
  body
} = node;

if (declare) {
  this.word("declare");
  this.space();
}

this.word("interface");
this.space();
this.print(id, node);
this.print(typeParameters, node);

if (extendz) {
  this.space();
  this.word("extends");
  this.space();
  this.printList(extendz, node);
}

this.space();
this.print(body, node);

}

function TSInterfaceBody(node) {

this.tsPrintTypeLiteralOrInterfaceBody(node.body, node);

}

function TSTypeAliasDeclaration(node) {

const {
  declare,
  id,
  typeParameters,
  typeAnnotation
} = node;

if (declare) {
  this.word("declare");
  this.space();
}

this.word("type");
this.space();
this.print(id, node);
this.print(typeParameters, node);
this.space();
this.token("=");
this.space();
this.print(typeAnnotation, node);
this.token(";");

}

function TSAsExpression(node) {

const {
  expression,
  typeAnnotation
} = node;
this.print(expression, node);
this.space();
this.word("as");
this.space();
this.print(typeAnnotation, node);

}

function TSTypeAssertion(node) {

const {
  typeAnnotation,
  expression
} = node;
this.token("<");
this.print(typeAnnotation, node);
this.token(">");
this.space();
this.print(expression, node);

}

function TSEnumDeclaration(node) {

const {
  declare,
  const: isConst,
  id,
  members
} = node;

if (declare) {
  this.word("declare");
  this.space();
}

if (isConst) {
  this.word("const");
  this.space();
}

this.word("enum");
this.space();
this.print(id, node);
this.space();
this.tsPrintBraced(members, node);

}

function TSEnumMember(node) {

const {
  id,
  initializer
} = node;
this.print(id, node);

if (initializer) {
  this.space();
  this.token("=");
  this.space();
  this.print(initializer, node);
}

this.token(",");

}

function TSModuleDeclaration(node) {

const {
  declare,
  id
} = node;

if (declare) {
  this.word("declare");
  this.space();
}

if (!node.global) {
  this.word(id.type === "Identifier" ? "namespace" : "module");
  this.space();
}

this.print(id, node);

if (!node.body) {
  this.token(";");
  return;
}

let body = node.body;

while (body.type === "TSModuleDeclaration") {
  this.token(".");
  this.print(body.id, body);
  body = body.body;
}

this.space();
this.print(body, node);

}

function TSModuleBlock(node) {

this.tsPrintBraced(node.body, node);

}

function TSImportType(node) {

const {
  argument,
  qualifier,
  typeParameters
} = node;
this.word("import");
this.token("(");
this.print(argument, node);
this.token(")");

if (qualifier) {
  this.token(".");
  this.print(qualifier, node);
}

if (typeParameters) {
  this.print(typeParameters, node);
}

}

function TSImportEqualsDeclaration(node) {

const {
  isExport,
  id,
  moduleReference
} = node;

if (isExport) {
  this.word("export");
  this.space();
}

this.word("import");
this.space();
this.print(id, node);
this.space();
this.token("=");
this.space();
this.print(moduleReference, node);
this.token(";");

}

function TSExternalModuleReference(node) {

this.token("require(");
this.print(node.expression, node);
this.token(")");

}

function TSNonNullExpression(node) {

this.print(node.expression, node);
this.token("!");

}

function TSExportAssignment(node) {

this.word("export");
this.space();
this.token("=");
this.space();
this.print(node.expression, node);
this.token(";");

}

function TSNamespaceExportDeclaration(node) {

this.word("export");
this.space();
this.word("as");
this.space();
this.word("namespace");
this.space();
this.print(node.id, node);

}

function tsPrintSignatureDeclarationBase(node) {

const {
  typeParameters,
  parameters
} = node;
this.print(typeParameters, node);
this.token("(");

this._parameters(parameters, node);

this.token(")");
this.print(node.typeAnnotation, node);

}