“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.patternLikeCommon = exports.functionDeclarationCommon = exports.functionTypeAnnotationCommon = exports.functionCommon = void 0;

var _isValidIdentifier = _interopRequireDefault(require(“../validators/isValidIdentifier”));

var _constants = require(“../constants”);

var _utils = _interopRequireWildcard(require(“./utils”));

function _getRequireWildcardCache() { if (typeof WeakMap !== “function”) return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj = obj; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

(0, _utils.default)(“ArrayExpression”, {

fields: {
  elements: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
    default: []
  }
},
visitor: ["elements"],
aliases: ["Expression"]

}); (0, _utils.default)(“AssignmentExpression”, {

fields: {
  operator: {
    validate: (0, _utils.assertValueType)("string")
  },
  left: {
    validate: (0, _utils.assertNodeType)("LVal")
  },
  right: {
    validate: (0, _utils.assertNodeType)("Expression")
  }
},
builder: ["operator", "left", "right"],
visitor: ["left", "right"],
aliases: ["Expression"]

}); (0, _utils.default)(“BinaryExpression”, {

builder: ["operator", "left", "right"],
fields: {
  operator: {
    validate: (0, _utils.assertOneOf)(..._constants.BINARY_OPERATORS)
  },
  left: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  right: {
    validate: (0, _utils.assertNodeType)("Expression")
  }
},
visitor: ["left", "right"],
aliases: ["Binary", "Expression"]

}); (0, _utils.default)(“InterpreterDirective”, {

builder: ["value"],
fields: {
  value: {
    validate: (0, _utils.assertValueType)("string")
  }
}

}); (0, _utils.default)(“Directive”, {

visitor: ["value"],
fields: {
  value: {
    validate: (0, _utils.assertNodeType)("DirectiveLiteral")
  }
}

}); (0, _utils.default)(“DirectiveLiteral”, {

builder: ["value"],
fields: {
  value: {
    validate: (0, _utils.assertValueType)("string")
  }
}

}); (0, _utils.default)(“BlockStatement”, {

builder: ["body", "directives"],
visitor: ["directives", "body"],
fields: {
  directives: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
    default: []
  },
  body: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
  }
},
aliases: ["Scopable", "BlockParent", "Block", "Statement"]

}); (0, _utils.default)(“BreakStatement”, {

visitor: ["label"],
fields: {
  label: {
    validate: (0, _utils.assertNodeType)("Identifier"),
    optional: true
  }
},
aliases: ["Statement", "Terminatorless", "CompletionStatement"]

}); (0, _utils.default)(“CallExpression”, {

visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
builder: ["callee", "arguments"],
aliases: ["Expression"],
fields: {
  callee: {
    validate: (0, _utils.assertNodeType)("Expression", "V8IntrinsicIdentifier")
  },
  arguments: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
  },
  optional: {
    validate: (0, _utils.assertOneOf)(true, false),
    optional: true
  },
  typeArguments: {
    validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
    optional: true
  },
  typeParameters: {
    validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
    optional: true
  }
}

}); (0, _utils.default)(“CatchClause”, {

visitor: ["param", "body"],
fields: {
  param: {
    validate: (0, _utils.assertNodeType)("Identifier"),
    optional: true
  },
  body: {
    validate: (0, _utils.assertNodeType)("BlockStatement")
  }
},
aliases: ["Scopable", "BlockParent"]

}); (0, _utils.default)(“ConditionalExpression”, {

visitor: ["test", "consequent", "alternate"],
fields: {
  test: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  consequent: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  alternate: {
    validate: (0, _utils.assertNodeType)("Expression")
  }
},
aliases: ["Expression", "Conditional"]

}); (0, _utils.default)(“ContinueStatement”, {

visitor: ["label"],
fields: {
  label: {
    validate: (0, _utils.assertNodeType)("Identifier"),
    optional: true
  }
},
aliases: ["Statement", "Terminatorless", "CompletionStatement"]

}); (0, _utils.default)(“DebuggerStatement”, {

aliases: ["Statement"]

}); (0, _utils.default)(“DoWhileStatement”, {

visitor: ["test", "body"],
fields: {
  test: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  body: {
    validate: (0, _utils.assertNodeType)("Statement")
  }
},
aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]

}); (0, _utils.default)(“EmptyStatement”, {

aliases: ["Statement"]

}); (0, _utils.default)(“ExpressionStatement”, {

visitor: ["expression"],
fields: {
  expression: {
    validate: (0, _utils.assertNodeType)("Expression")
  }
},
aliases: ["Statement", "ExpressionWrapper"]

}); (0, _utils.default)(“File”, {

builder: ["program", "comments", "tokens"],
visitor: ["program"],
fields: {
  program: {
    validate: (0, _utils.assertNodeType)("Program")
  }
}

}); (0, _utils.default)(“ForInStatement”, {

visitor: ["left", "right", "body"],
aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
fields: {
  left: {
    validate: (0, _utils.assertNodeType)("VariableDeclaration", "LVal")
  },
  right: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  body: {
    validate: (0, _utils.assertNodeType)("Statement")
  }
}

}); (0, _utils.default)(“ForStatement”, {

visitor: ["init", "test", "update", "body"],
aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"],
fields: {
  init: {
    validate: (0, _utils.assertNodeType)("VariableDeclaration", "Expression"),
    optional: true
  },
  test: {
    validate: (0, _utils.assertNodeType)("Expression"),
    optional: true
  },
  update: {
    validate: (0, _utils.assertNodeType)("Expression"),
    optional: true
  },
  body: {
    validate: (0, _utils.assertNodeType)("Statement")
  }
}

}); const functionCommon = {

params: {
  validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty")))
},
generator: {
  default: false,
  validate: (0, _utils.assertValueType)("boolean")
},
async: {
  validate: (0, _utils.assertValueType)("boolean"),
  default: false
}

}; exports.functionCommon = functionCommon; const functionTypeAnnotationCommon = {

returnType: {
  validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
  optional: true
},
typeParameters: {
  validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
  optional: true
}

}; exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon; const functionDeclarationCommon = Object.assign({}, functionCommon, {

declare: {
  validate: (0, _utils.assertValueType)("boolean"),
  optional: true
},
id: {
  validate: (0, _utils.assertNodeType)("Identifier"),
  optional: true
}

}); exports.functionDeclarationCommon = functionDeclarationCommon; (0, _utils.default)(“FunctionDeclaration”, {

builder: ["id", "params", "body", "generator", "async"],
visitor: ["id", "params", "body", "returnType", "typeParameters"],
fields: Object.assign({}, functionDeclarationCommon, {}, functionTypeAnnotationCommon, {
  body: {
    validate: (0, _utils.assertNodeType)("BlockStatement")
  }
}),
aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"]

}); (0, _utils.default)(“FunctionExpression”, {

inherits: "FunctionDeclaration",
aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
fields: Object.assign({}, functionCommon, {}, functionTypeAnnotationCommon, {
  id: {
    validate: (0, _utils.assertNodeType)("Identifier"),
    optional: true
  },
  body: {
    validate: (0, _utils.assertNodeType)("BlockStatement")
  }
})

}); const patternLikeCommon = {

typeAnnotation: {
  validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
  optional: true
},
decorators: {
  validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
}

}; exports.patternLikeCommon = patternLikeCommon; (0, _utils.default)(“Identifier”, {

builder: ["name"],
visitor: ["typeAnnotation", "decorators"],
aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"],
fields: Object.assign({}, patternLikeCommon, {
  name: {
    validate: (0, _utils.chain)(function (node, key, val) {
      if (!(0, _isValidIdentifier.default)(val)) {}
    }, (0, _utils.assertValueType)("string"))
  },
  optional: {
    validate: (0, _utils.assertValueType)("boolean"),
    optional: true
  }
})

}); (0, _utils.default)(“IfStatement”, {

visitor: ["test", "consequent", "alternate"],
aliases: ["Statement", "Conditional"],
fields: {
  test: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  consequent: {
    validate: (0, _utils.assertNodeType)("Statement")
  },
  alternate: {
    optional: true,
    validate: (0, _utils.assertNodeType)("Statement")
  }
}

}); (0, _utils.default)(“LabeledStatement”, {

visitor: ["label", "body"],
aliases: ["Statement"],
fields: {
  label: {
    validate: (0, _utils.assertNodeType)("Identifier")
  },
  body: {
    validate: (0, _utils.assertNodeType)("Statement")
  }
}

}); (0, _utils.default)(“StringLiteral”, {

builder: ["value"],
fields: {
  value: {
    validate: (0, _utils.assertValueType)("string")
  }
},
aliases: ["Expression", "Pureish", "Literal", "Immutable"]

}); (0, _utils.default)(“NumericLiteral”, {

builder: ["value"],
deprecatedAlias: "NumberLiteral",
fields: {
  value: {
    validate: (0, _utils.assertValueType)("number")
  }
},
aliases: ["Expression", "Pureish", "Literal", "Immutable"]

}); (0, _utils.default)(“NullLiteral”, {

aliases: ["Expression", "Pureish", "Literal", "Immutable"]

}); (0, _utils.default)(“BooleanLiteral”, {

builder: ["value"],
fields: {
  value: {
    validate: (0, _utils.assertValueType)("boolean")
  }
},
aliases: ["Expression", "Pureish", "Literal", "Immutable"]

}); (0, _utils.default)(“RegExpLiteral”, {

builder: ["pattern", "flags"],
deprecatedAlias: "RegexLiteral",
aliases: ["Expression", "Literal"],
fields: {
  pattern: {
    validate: (0, _utils.assertValueType)("string")
  },
  flags: {
    validate: (0, _utils.assertValueType)("string"),
    default: ""
  }
}

}); (0, _utils.default)(“LogicalExpression”, {

builder: ["operator", "left", "right"],
visitor: ["left", "right"],
aliases: ["Binary", "Expression"],
fields: {
  operator: {
    validate: (0, _utils.assertOneOf)(..._constants.LOGICAL_OPERATORS)
  },
  left: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  right: {
    validate: (0, _utils.assertNodeType)("Expression")
  }
}

}); (0, _utils.default)(“MemberExpression”, {

builder: ["object", "property", "computed", "optional"],
visitor: ["object", "property"],
aliases: ["Expression", "LVal"],
fields: {
  object: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  property: {
    validate: function () {
      const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName");
      const computed = (0, _utils.assertNodeType)("Expression");
      return function (node, key, val) {
        const validator = node.computed ? computed : normal;
        validator(node, key, val);
      };
    }()
  },
  computed: {
    default: false
  },
  optional: {
    validate: (0, _utils.assertOneOf)(true, false),
    optional: true
  }
}

}); (0, _utils.default)(“NewExpression”, {

inherits: "CallExpression"

}); (0, _utils.default)(“Program”, {

visitor: ["directives", "body"],
builder: ["body", "directives", "sourceType", "interpreter"],
fields: {
  sourceFile: {
    validate: (0, _utils.assertValueType)("string")
  },
  sourceType: {
    validate: (0, _utils.assertOneOf)("script", "module"),
    default: "script"
  },
  interpreter: {
    validate: (0, _utils.assertNodeType)("InterpreterDirective"),
    default: null,
    optional: true
  },
  directives: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
    default: []
  },
  body: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
  }
},
aliases: ["Scopable", "BlockParent", "Block"]

}); (0, _utils.default)(“ObjectExpression”, {

visitor: ["properties"],
aliases: ["Expression"],
fields: {
  properties: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement")))
  }
}

}); (0, _utils.default)(“ObjectMethod”, {

builder: ["kind", "key", "params", "body", "computed"],
fields: Object.assign({}, functionCommon, {}, functionTypeAnnotationCommon, {
  kind: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("method", "get", "set")),
    default: "method"
  },
  computed: {
    validate: (0, _utils.assertValueType)("boolean"),
    default: false
  },
  key: {
    validate: function () {
      const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
      const computed = (0, _utils.assertNodeType)("Expression");
      return function (node, key, val) {
        const validator = node.computed ? computed : normal;
        validator(node, key, val);
      };
    }()
  },
  decorators: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
  },
  body: {
    validate: (0, _utils.assertNodeType)("BlockStatement")
  }
}),
visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"]

}); (0, _utils.default)(“ObjectProperty”, {

builder: ["key", "value", "computed", "shorthand", "decorators"],
fields: {
  computed: {
    validate: (0, _utils.assertValueType)("boolean"),
    default: false
  },
  key: {
    validate: function () {
      const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
      const computed = (0, _utils.assertNodeType)("Expression");
      return function (node, key, val) {
        const validator = node.computed ? computed : normal;
        validator(node, key, val);
      };
    }()
  },
  value: {
    validate: (0, _utils.assertNodeType)("Expression", "PatternLike")
  },
  shorthand: {
    validate: (0, _utils.assertValueType)("boolean"),
    default: false
  },
  decorators: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
    optional: true
  }
},
visitor: ["key", "value", "decorators"],
aliases: ["UserWhitespacable", "Property", "ObjectMember"]

}); (0, _utils.default)(“RestElement”, {

visitor: ["argument", "typeAnnotation"],
builder: ["argument"],
aliases: ["LVal", "PatternLike"],
deprecatedAlias: "RestProperty",
fields: Object.assign({}, patternLikeCommon, {
  argument: {
    validate: (0, _utils.assertNodeType)("LVal")
  }
})

}); (0, _utils.default)(“ReturnStatement”, {

visitor: ["argument"],
aliases: ["Statement", "Terminatorless", "CompletionStatement"],
fields: {
  argument: {
    validate: (0, _utils.assertNodeType)("Expression"),
    optional: true
  }
}

}); (0, _utils.default)(“SequenceExpression”, {

visitor: ["expressions"],
fields: {
  expressions: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression")))
  }
},
aliases: ["Expression"]

}); (0, _utils.default)(“ParenthesizedExpression”, {

visitor: ["expression"],
aliases: ["Expression", "ExpressionWrapper"],
fields: {
  expression: {
    validate: (0, _utils.assertNodeType)("Expression")
  }
}

}); (0, _utils.default)(“SwitchCase”, {

visitor: ["test", "consequent"],
fields: {
  test: {
    validate: (0, _utils.assertNodeType)("Expression"),
    optional: true
  },
  consequent: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
  }
}

}); (0, _utils.default)(“SwitchStatement”, {

visitor: ["discriminant", "cases"],
aliases: ["Statement", "BlockParent", "Scopable"],
fields: {
  discriminant: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  cases: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("SwitchCase")))
  }
}

}); (0, _utils.default)(“ThisExpression”, {

aliases: ["Expression"]

}); (0, _utils.default)(“ThrowStatement”, {

visitor: ["argument"],
aliases: ["Statement", "Terminatorless", "CompletionStatement"],
fields: {
  argument: {
    validate: (0, _utils.assertNodeType)("Expression")
  }
}

}); (0, _utils.default)(“TryStatement”, {

visitor: ["block", "handler", "finalizer"],
aliases: ["Statement"],
fields: {
  block: {
    validate: (0, _utils.assertNodeType)("BlockStatement")
  },
  handler: {
    optional: true,
    validate: (0, _utils.assertNodeType)("CatchClause")
  },
  finalizer: {
    optional: true,
    validate: (0, _utils.assertNodeType)("BlockStatement")
  }
}

}); (0, _utils.default)(“UnaryExpression”, {

builder: ["operator", "argument", "prefix"],
fields: {
  prefix: {
    default: true
  },
  argument: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  operator: {
    validate: (0, _utils.assertOneOf)(..._constants.UNARY_OPERATORS)
  }
},
visitor: ["argument"],
aliases: ["UnaryLike", "Expression"]

}); (0, _utils.default)(“UpdateExpression”, {

builder: ["operator", "argument", "prefix"],
fields: {
  prefix: {
    default: false
  },
  argument: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  operator: {
    validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS)
  }
},
visitor: ["argument"],
aliases: ["Expression"]

}); (0, _utils.default)(“VariableDeclaration”, {

builder: ["kind", "declarations"],
visitor: ["declarations"],
aliases: ["Statement", "Declaration"],
fields: {
  declare: {
    validate: (0, _utils.assertValueType)("boolean"),
    optional: true
  },
  kind: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("var", "let", "const"))
  },
  declarations: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator")))
  }
}

}); (0, _utils.default)(“VariableDeclarator”, {

visitor: ["id", "init"],
fields: {
  id: {
    validate: (0, _utils.assertNodeType)("LVal")
  },
  definite: {
    optional: true,
    validate: (0, _utils.assertValueType)("boolean")
  },
  init: {
    optional: true,
    validate: (0, _utils.assertNodeType)("Expression")
  }
}

}); (0, _utils.default)(“WhileStatement”, {

visitor: ["test", "body"],
aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"],
fields: {
  test: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  body: {
    validate: (0, _utils.assertNodeType)("BlockStatement", "Statement")
  }
}

}); (0, _utils.default)(“WithStatement”, {

visitor: ["object", "body"],
aliases: ["Statement"],
fields: {
  object: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  body: {
    validate: (0, _utils.assertNodeType)("BlockStatement", "Statement")
  }
}

});