ast-types 0.11.5 → 0.12.1

package/def/core.js

@@ -1,133 +1,113 @@
-module.exports = function (fork) {
-    var types = fork.use(require("../lib/types"));
+"use strict";;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var types_1 = __importDefault(require("../lib/types"));
+var shared_1 = __importDefault(require("../lib/shared"));
+function default_1(fork) {
+    var types = fork.use(types_1.default);
     var Type = types.Type;
     var def = Type.def;
     var or = Type.or;
-    var shared = fork.use(require("../lib/shared"));
+    var shared = fork.use(shared_1.default);
     var defaults = shared.defaults;
     var geq = shared.geq;
-
     // Abstract supertype of all syntactic entities that are allowed to have a
     // .loc field.
     def("Printable")
-        .field("loc", or(
-            def("SourceLocation"),
-            null
-        ), defaults["null"], true);
-
+        .field("loc", or(def("SourceLocation"), null), defaults["null"], true);
     def("Node")
         .bases("Printable")
         .field("type", String)
-        .field("comments", or(
-            [def("Comment")],
-            null
-        ), defaults["null"], true);
-
+        .field("comments", or([def("Comment")], null), defaults["null"], true);
     def("SourceLocation")
-        .build("start", "end", "source")
         .field("start", def("Position"))
         .field("end", def("Position"))
         .field("source", or(String, null), defaults["null"]);
-
     def("Position")
-        .build("line", "column")
         .field("line", geq(1))
         .field("column", geq(0));
-
     def("File")
         .bases("Node")
         .build("program", "name")
         .field("program", def("Program"))
         .field("name", or(String, null), defaults["null"]);
-
     def("Program")
         .bases("Node")
         .build("body")
         .field("body", [def("Statement")]);
-
     def("Function")
         .bases("Node")
         .field("id", or(def("Identifier"), null), defaults["null"])
         .field("params", [def("Pattern")])
-        .field("body", def("BlockStatement"));
-
+        .field("body", def("BlockStatement"))
+        .field("generator", Boolean, defaults["false"])
+        .field("async", Boolean, defaults["false"]);
     def("Statement").bases("Node");
-
-// The empty .build() here means that an EmptyStatement can be constructed
-// (i.e. it's not abstract) but that it needs no arguments.
+    // The empty .build() here means that an EmptyStatement can be constructed
+    // (i.e. it's not abstract) but that it needs no arguments.
     def("EmptyStatement").bases("Statement").build();
-
     def("BlockStatement")
         .bases("Statement")
         .build("body")
         .field("body", [def("Statement")]);
-
     // TODO Figure out how to silently coerce Expressions to
     // ExpressionStatements where a Statement was expected.
     def("ExpressionStatement")
         .bases("Statement")
         .build("expression")
         .field("expression", def("Expression"));
-
     def("IfStatement")
         .bases("Statement")
         .build("test", "consequent", "alternate")
         .field("test", def("Expression"))
         .field("consequent", def("Statement"))
         .field("alternate", or(def("Statement"), null), defaults["null"]);
-
     def("LabeledStatement")
         .bases("Statement")
         .build("label", "body")
         .field("label", def("Identifier"))
         .field("body", def("Statement"));
-
     def("BreakStatement")
         .bases("Statement")
         .build("label")
         .field("label", or(def("Identifier"), null), defaults["null"]);
-
     def("ContinueStatement")
         .bases("Statement")
         .build("label")
         .field("label", or(def("Identifier"), null), defaults["null"]);
-
     def("WithStatement")
         .bases("Statement")
         .build("object", "body")
         .field("object", def("Expression"))
         .field("body", def("Statement"));
-
     def("SwitchStatement")
         .bases("Statement")
         .build("discriminant", "cases", "lexical")
         .field("discriminant", def("Expression"))
         .field("cases", [def("SwitchCase")])
         .field("lexical", Boolean, defaults["false"]);
-
     def("ReturnStatement")
         .bases("Statement")
         .build("argument")
         .field("argument", or(def("Expression"), null));
-
     def("ThrowStatement")
         .bases("Statement")
         .build("argument")
         .field("argument", def("Expression"));
-
     def("TryStatement")
         .bases("Statement")
         .build("block", "handler", "finalizer")
         .field("block", def("BlockStatement"))
         .field("handler", or(def("CatchClause"), null), function () {
-            return this.handlers && this.handlers[0] || null;
-        })
+        return this.handlers && this.handlers[0] || null;
+    })
         .field("handlers", [def("CatchClause")], function () {
-            return this.handler ? [this.handler] : [];
-        }, true) // Indicates this field is hidden from eachField iteration.
+        return this.handler ? [this.handler] : [];
+    }, true) // Indicates this field is hidden from eachField iteration.
         .field("guardedHandlers", [def("CatchClause")], defaults.emptyArray)
         .field("finalizer", or(def("BlockStatement"), null), defaults["null"]);
-
     def("CatchClause")
         .bases("Node")
         .build("param", "guard", "body")
@@ -135,79 +115,59 @@ module.exports = function (fork) {
         .field("param", or(def("Pattern"), null), defaults["null"])
         .field("guard", or(def("Expression"), null), defaults["null"])
         .field("body", def("BlockStatement"));
-
     def("WhileStatement")
         .bases("Statement")
         .build("test", "body")
         .field("test", def("Expression"))
         .field("body", def("Statement"));
-
     def("DoWhileStatement")
         .bases("Statement")
         .build("body", "test")
         .field("body", def("Statement"))
         .field("test", def("Expression"));
-
     def("ForStatement")
         .bases("Statement")
         .build("init", "test", "update", "body")
-        .field("init", or(
-            def("VariableDeclaration"),
-            def("Expression"),
-            null))
+        .field("init", or(def("VariableDeclaration"), def("Expression"), null))
         .field("test", or(def("Expression"), null))
         .field("update", or(def("Expression"), null))
         .field("body", def("Statement"));
-
     def("ForInStatement")
         .bases("Statement")
         .build("left", "right", "body")
-        .field("left", or(
-            def("VariableDeclaration"),
-            def("Expression")))
+        .field("left", or(def("VariableDeclaration"), def("Expression")))
         .field("right", def("Expression"))
         .field("body", def("Statement"));
-
     def("DebuggerStatement").bases("Statement").build();
-
     def("Declaration").bases("Statement");
-
     def("FunctionDeclaration")
         .bases("Function", "Declaration")
         .build("id", "params", "body")
         .field("id", def("Identifier"));
-
     def("FunctionExpression")
         .bases("Function", "Expression")
         .build("id", "params", "body");
-
     def("VariableDeclaration")
         .bases("Declaration")
         .build("kind", "declarations")
         .field("kind", or("var", "let", "const"))
         .field("declarations", [def("VariableDeclarator")]);
-
     def("VariableDeclarator")
         .bases("Node")
         .build("id", "init")
         .field("id", def("Pattern"))
-        .field("init", or(def("Expression"), null));
-
+        .field("init", or(def("Expression"), null), defaults["null"]);
     // TODO Are all Expressions really Patterns?
     def("Expression").bases("Node", "Pattern");
-
     def("ThisExpression").bases("Expression").build();
-
     def("ArrayExpression")
         .bases("Expression")
         .build("elements")
         .field("elements", [or(def("Expression"), null)]);
-
     def("ObjectExpression")
         .bases("Expression")
         .build("properties")
         .field("properties", [def("Property")]);
-
     // TODO Not in the Mozilla Parser API, but used by Esprima.
     def("Property")
         .bases("Node") // Want to be able to visit Property Nodes.
@@ -215,16 +175,11 @@ module.exports = function (fork) {
         .field("kind", or("init", "get", "set"))
         .field("key", or(def("Literal"), def("Identifier")))
         .field("value", def("Expression"));
-
     def("SequenceExpression")
         .bases("Expression")
         .build("expressions")
         .field("expressions", [def("Expression")]);
-
-    var UnaryOperator = or(
-        "-", "+", "!", "~",
-        "typeof", "void", "delete");
-
+    var UnaryOperator = or("-", "+", "!", "~", "typeof", "void", "delete");
     def("UnaryExpression")
         .bases("Expression")
         .build("operator", "argument", "prefix")
@@ -233,60 +188,41 @@ module.exports = function (fork) {
         // Esprima doesn't bother with this field, presumably because it's
         // always true for unary operators.
         .field("prefix", Boolean, defaults["true"]);
-
-    var BinaryOperator = or(
-        "==", "!=", "===", "!==",
-        "<", "<=", ">", ">=",
-        "<<", ">>", ">>>",
-        "+", "-", "*", "/", "%", "**",
-        "&", // TODO Missing from the Parser API.
-        "|", "^", "in",
-        "instanceof", "..");
-
+    var BinaryOperator = or("==", "!=", "===", "!==", "<", "<=", ">", ">=", "<<", ">>", ">>>", "+", "-", "*", "/", "%", "**", "&", // TODO Missing from the Parser API.
+    "|", "^", "in", "instanceof", "..");
     def("BinaryExpression")
         .bases("Expression")
         .build("operator", "left", "right")
         .field("operator", BinaryOperator)
         .field("left", def("Expression"))
         .field("right", def("Expression"));
-
-    var AssignmentOperator = or(
-        "=", "+=", "-=", "*=", "/=", "%=",
-        "<<=", ">>=", ">>>=",
-        "|=", "^=", "&=");
-
+    var AssignmentOperator = or("=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "|=", "^=", "&=");
     def("AssignmentExpression")
         .bases("Expression")
         .build("operator", "left", "right")
         .field("operator", AssignmentOperator)
         .field("left", def("Pattern"))
         .field("right", def("Expression"));
-
     var UpdateOperator = or("++", "--");
-
     def("UpdateExpression")
         .bases("Expression")
         .build("operator", "argument", "prefix")
         .field("operator", UpdateOperator)
         .field("argument", def("Expression"))
         .field("prefix", Boolean);
-
     var LogicalOperator = or("||", "&&");
-
     def("LogicalExpression")
         .bases("Expression")
         .build("operator", "left", "right")
         .field("operator", LogicalOperator)
         .field("left", def("Expression"))
         .field("right", def("Expression"));
-
     def("ConditionalExpression")
         .bases("Expression")
         .build("test", "consequent", "alternate")
         .field("test", def("Expression"))
         .field("consequent", def("Expression"))
         .field("alternate", def("Expression"));
-
     def("NewExpression")
         .bases("Expression")
         .build("callee", "arguments")
@@ -295,69 +231,62 @@ module.exports = function (fork) {
         // null)], but null values don't really make sense at the call site.
         // TODO Report this nonsense.
         .field("arguments", [def("Expression")]);
-
     def("CallExpression")
         .bases("Expression")
         .build("callee", "arguments")
         .field("callee", def("Expression"))
         // See comment for NewExpression above.
         .field("arguments", [def("Expression")]);
-
     def("MemberExpression")
         .bases("Expression")
         .build("object", "property", "computed")
         .field("object", def("Expression"))
         .field("property", or(def("Identifier"), def("Expression")))
         .field("computed", Boolean, function () {
-            var type = this.property.type;
-            if (type === 'Literal' ||
-                type === 'MemberExpression' ||
-                type === 'BinaryExpression') {
-                return true;
-            }
-            return false;
-        });
-
+        var type = this.property.type;
+        if (type === 'Literal' ||
+            type === 'MemberExpression' ||
+            type === 'BinaryExpression') {
+            return true;
+        }
+        return false;
+    });
     def("Pattern").bases("Node");
-
     def("SwitchCase")
         .bases("Node")
         .build("test", "consequent")
         .field("test", or(def("Expression"), null))
         .field("consequent", [def("Statement")]);
-
     def("Identifier")
         // But aren't Expressions and Patterns already Nodes? TODO Report this.
         .bases("Node", "Expression", "Pattern")
         .build("name")
         .field("name", String)
         .field("optional", Boolean, defaults["false"]);
-
     def("Literal")
         // But aren't Expressions already Nodes? TODO Report this.
         .bases("Node", "Expression")
         .build("value")
         .field("value", or(String, Boolean, null, Number, RegExp))
         .field("regex", or({
-            pattern: String,
-            flags: String
-        }, null), function () {
-            if (this.value instanceof RegExp) {
-                var flags = "";
-
-                if (this.value.ignoreCase) flags += "i";
-                if (this.value.multiline) flags += "m";
-                if (this.value.global) flags += "g";
-
-                return {
-                    pattern: this.value.source,
-                    flags: flags
-                };
-            }
-
-            return null;
-        });
-
+        pattern: String,
+        flags: String
+    }, null), function () {
+        if (this.value instanceof RegExp) {
+            var flags = "";
+            if (this.value.ignoreCase)
+                flags += "i";
+            if (this.value.multiline)
+                flags += "m";
+            if (this.value.global)
+                flags += "g";
+            return {
+                pattern: this.value.source,
+                flags: flags
+            };
+        }
+        return null;
+    });
     // Abstract (non-buildable) comment supertype. Not a Node.
     def("Comment")
         .bases("Printable")
@@ -369,4 +298,6 @@ module.exports = function (fork) {
         // e.g. { /*dangling*/ }.
         .field("leading", Boolean, defaults["true"])
         .field("trailing", Boolean, defaults["false"]);
-};
+}
+exports.default = default_1;
+module.exports = exports["default"];

package/def/es-proposals.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;

package/def/es-proposals.js

@@ -1,33 +1,35 @@
-module.exports = function (fork) {
-  fork.use(require('./core'));
-
-  var types = fork.use(require("../lib/types"));
-  var Type = types.Type;
-  var def = types.Type.def;
-  var or = Type.or;
-
-  var shared = fork.use(require("../lib/shared"));
-  var defaults = shared.defaults;
-
-
-  // https://github.com/tc39/proposal-optional-chaining
-  // `a?.b` as per https://github.com/estree/estree/issues/146
-  def("OptionalMemberExpression")
-    .bases("MemberExpression")
-    .build("object", "property", "computed", "optional")
-    .field("optional", Boolean, defaults["true"])
-
-  // a?.b()
-  def("OptionalCallExpression")
-    .bases("CallExpression")
-    .build("callee", "arguments", "optional")
-    .field("optional", Boolean, defaults["true"])
-
-
-  // https://github.com/tc39/proposal-nullish-coalescing
-  // `a ?? b` as per https://github.com/babel/babylon/pull/761/files
-  var LogicalOperator = or("||", "&&", "??");
-
-  def("LogicalExpression")
-    .field("operator", LogicalOperator)
+"use strict";;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+var types_1 = __importDefault(require("../lib/types"));
+var shared_1 = __importDefault(require("../lib/shared"));
+var core_1 = __importDefault(require("./core"));
+function default_1(fork) {
+    fork.use(core_1.default);
+    var types = fork.use(types_1.default);
+    var Type = types.Type;
+    var def = types.Type.def;
+    var or = Type.or;
+    var shared = fork.use(shared_1.default);
+    var defaults = shared.defaults;
+    // https://github.com/tc39/proposal-optional-chaining
+    // `a?.b` as per https://github.com/estree/estree/issues/146
+    def("OptionalMemberExpression")
+        .bases("MemberExpression")
+        .build("object", "property", "computed", "optional")
+        .field("optional", Boolean, defaults["true"]);
+    // a?.b()
+    def("OptionalCallExpression")
+        .bases("CallExpression")
+        .build("callee", "arguments", "optional")
+        .field("optional", Boolean, defaults["true"]);
+    // https://github.com/tc39/proposal-nullish-coalescing
+    // `a ?? b` as per https://github.com/babel/babylon/pull/761/files
+    var LogicalOperator = or("||", "&&", "??");
+    def("LogicalExpression")
+        .field("operator", LogicalOperator);
+}
+exports.default = default_1;
+module.exports = exports["default"];

package/def/es6.d.ts

@@ -0,0 +1,2 @@
+import { Fork } from "../types";
+export default function (fork: Fork): void;