“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.classMethodOrDeclareMethodCommon = exports.classMethodOrPropertyCommon = void 0;

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

var _core = require(“./core”);

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; }

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

visitor: ["left", "right", "decorators"],
builder: ["left", "right"],
aliases: ["Pattern", "PatternLike", "LVal"],
fields: Object.assign({}, _core.patternLikeCommon, {
  left: {
    validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression")
  },
  right: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  decorators: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
  }
})

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

visitor: ["elements", "typeAnnotation"],
builder: ["elements"],
aliases: ["Pattern", "PatternLike", "LVal"],
fields: Object.assign({}, _core.patternLikeCommon, {
  elements: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("PatternLike")))
  },
  decorators: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
  }
})

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

builder: ["params", "body", "async"],
visitor: ["params", "body", "returnType", "typeParameters"],
aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
fields: Object.assign({}, _core.functionCommon, {}, _core.functionTypeAnnotationCommon, {
  expression: {
    validate: (0, _utils.assertValueType)("boolean")
  },
  body: {
    validate: (0, _utils.assertNodeType)("BlockStatement", "Expression")
  }
})

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

visitor: ["body"],
fields: {
  body: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "TSDeclareMethod", "TSIndexSignature")))
  }
}

}); const classCommon = {

typeParameters: {
  validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
  optional: true
},
body: {
  validate: (0, _utils.assertNodeType)("ClassBody")
},
superClass: {
  optional: true,
  validate: (0, _utils.assertNodeType)("Expression")
},
superTypeParameters: {
  validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
  optional: true
},
implements: {
  validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
  optional: true
}

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

builder: ["id", "superClass", "body", "decorators"],
visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"],
aliases: ["Scopable", "Class", "Statement", "Declaration", "Pureish"],
fields: Object.assign({}, classCommon, {
  declare: {
    validate: (0, _utils.assertValueType)("boolean"),
    optional: true
  },
  abstract: {
    validate: (0, _utils.assertValueType)("boolean"),
    optional: true
  },
  id: {
    validate: (0, _utils.assertNodeType)("Identifier"),
    optional: true
  },
  decorators: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
    optional: true
  }
})

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

inherits: "ClassDeclaration",
aliases: ["Scopable", "Class", "Expression", "Pureish"],
fields: Object.assign({}, classCommon, {
  id: {
    optional: true,
    validate: (0, _utils.assertNodeType)("Identifier")
  },
  body: {
    validate: (0, _utils.assertNodeType)("ClassBody")
  },
  superClass: {
    optional: true,
    validate: (0, _utils.assertNodeType)("Expression")
  },
  decorators: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
    optional: true
  }
})

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

visitor: ["source"],
aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
fields: {
  source: {
    validate: (0, _utils.assertNodeType)("StringLiteral")
  }
}

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

visitor: ["declaration"],
aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
fields: {
  declaration: {
    validate: (0, _utils.assertNodeType)("FunctionDeclaration", "TSDeclareFunction", "ClassDeclaration", "Expression")
  }
}

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

visitor: ["declaration", "specifiers", "source"],
aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
fields: {
  declaration: {
    validate: (0, _utils.assertNodeType)("Declaration"),
    optional: true
  },
  specifiers: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier")))
  },
  source: {
    validate: (0, _utils.assertNodeType)("StringLiteral"),
    optional: true
  },
  exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
}

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

visitor: ["local", "exported"],
aliases: ["ModuleSpecifier"],
fields: {
  local: {
    validate: (0, _utils.assertNodeType)("Identifier")
  },
  exported: {
    validate: (0, _utils.assertNodeType)("Identifier")
  }
}

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

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")
  },
  await: {
    default: false,
    validate: (0, _utils.assertValueType)("boolean")
  }
}

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

visitor: ["specifiers", "source"],
aliases: ["Statement", "Declaration", "ModuleDeclaration"],
fields: {
  specifiers: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier")))
  },
  source: {
    validate: (0, _utils.assertNodeType)("StringLiteral")
  },
  importKind: {
    validate: (0, _utils.assertOneOf)("type", "typeof", "value"),
    optional: true
  }
}

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

visitor: ["local"],
aliases: ["ModuleSpecifier"],
fields: {
  local: {
    validate: (0, _utils.assertNodeType)("Identifier")
  }
}

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

visitor: ["local"],
aliases: ["ModuleSpecifier"],
fields: {
  local: {
    validate: (0, _utils.assertNodeType)("Identifier")
  }
}

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

visitor: ["local", "imported"],
aliases: ["ModuleSpecifier"],
fields: {
  local: {
    validate: (0, _utils.assertNodeType)("Identifier")
  },
  imported: {
    validate: (0, _utils.assertNodeType)("Identifier")
  },
  importKind: {
    validate: (0, _utils.assertOneOf)("type", "typeof"),
    optional: true
  }
}

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

visitor: ["meta", "property"],
aliases: ["Expression"],
fields: {
  meta: {
    validate: (0, _utils.assertNodeType)("Identifier")
  },
  property: {
    validate: (0, _utils.assertNodeType)("Identifier")
  }
}

}); const classMethodOrPropertyCommon = {

abstract: {
  validate: (0, _utils.assertValueType)("boolean"),
  optional: true
},
accessibility: {
  validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")),
  optional: true
},
static: {
  default: false,
  validate: (0, _utils.assertValueType)("boolean")
},
computed: {
  default: false,
  validate: (0, _utils.assertValueType)("boolean")
},
optional: {
  validate: (0, _utils.assertValueType)("boolean"),
  optional: true
},
key: {
  validate: (0, _utils.chain)(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);
    };
  }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression"))
}

}; exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon; const classMethodOrDeclareMethodCommon = Object.assign({}, _core.functionCommon, {}, classMethodOrPropertyCommon, {

kind: {
  validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("get", "set", "method", "constructor")),
  default: "method"
},
access: {
  validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")),
  optional: true
},
decorators: {
  validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
  optional: true
}

}); exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon; (0, _utils.default)(“ClassMethod”, {

aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
builder: ["kind", "key", "params", "body", "computed", "static"],
visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
fields: Object.assign({}, classMethodOrDeclareMethodCommon, {}, _core.functionTypeAnnotationCommon, {
  body: {
    validate: (0, _utils.assertNodeType)("BlockStatement")
  }
})

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

visitor: ["properties", "typeAnnotation", "decorators"],
builder: ["properties"],
aliases: ["Pattern", "PatternLike", "LVal"],
fields: Object.assign({}, _core.patternLikeCommon, {
  properties: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty")))
  }
})

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

visitor: ["argument"],
aliases: ["UnaryLike"],
deprecatedAlias: "SpreadProperty",
fields: {
  argument: {
    validate: (0, _utils.assertNodeType)("Expression")
  }
}

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

aliases: ["Expression"]

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

visitor: ["tag", "quasi"],
aliases: ["Expression"],
fields: {
  tag: {
    validate: (0, _utils.assertNodeType)("Expression")
  },
  quasi: {
    validate: (0, _utils.assertNodeType)("TemplateLiteral")
  },
  typeParameters: {
    validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
    optional: true
  }
}

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

builder: ["value", "tail"],
fields: {
  value: {
    validate: (0, _utils.assertShape)({
      raw: {
        validate: (0, _utils.assertValueType)("string")
      },
      cooked: {
        validate: (0, _utils.assertValueType)("string"),
        optional: true
      }
    })
  },
  tail: {
    validate: (0, _utils.assertValueType)("boolean"),
    default: false
  }
}

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

visitor: ["quasis", "expressions"],
aliases: ["Expression", "Literal"],
fields: {
  quasis: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TemplateElement")))
  },
  expressions: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression")), function (node, key, val) {
      if (node.quasis.length !== val.length + 1) {
        throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of expressions.\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`);
      }
    })
  }
}

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

builder: ["argument", "delegate"],
visitor: ["argument"],
aliases: ["Expression", "Terminatorless"],
fields: {
  delegate: {
    validate: (0, _utils.assertValueType)("boolean"),
    default: false
  },
  argument: {
    optional: true,
    validate: (0, _utils.assertNodeType)("Expression")
  }
}

});