spider-src 0.1.5

data/lib/spider-src/support/spider/lib/ast/statements/FallthroughStatement.js

@@ -0,0 +1,74 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function FallthroughStatement() {
+    Node.call(this);
+    this.type = "FallthroughStatement";
+  }
+  FallthroughStatement.prototype = Object.create(Node);
+  FallthroughStatement.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var parent = this.parent;
+    var iterations = 0;
+    while (!!(typeof parent !== "undefined" && parent !== null) && !parent.switchCase) {
+      parent = parent.parent;
+      iterations++;
+    }
+    if (typeof parent !== "undefined" && parent !== null) {
+      parent.fallthrough = true;
+    } else {
+      Node.getErrorManager().error({
+        type: "InvalidFallthroughContext",
+        message: "fallthrough statement is only allowed in a switch case clause.",
+        loc: this.loc
+      });
+    }
+    var switchStatement = parent.parent;
+    if (!switchStatement.fallthroughId) {
+      switchStatement.fallthroughId = {
+        "type": "Identifier",
+        "name": FallthroughStatement.getNextVariableName()
+      };
+    }
+    switchStatement.branchFallthrough = true;
+    parent.body.body = [{
+      "type": "ExpressionStatement",
+      "codeGenerated": true,
+      "expression": {
+        "type": "AssignmentExpression",
+        "operator": "=",
+        "left": switchStatement.fallthroughId,
+        "right": {
+          "type": "Literal",
+          "value": 2
+        }
+      }
+    }].concat(parent.body.body);
+    this.type = "ExpressionStatement";
+    this.expression = {
+      "type": "AssignmentExpression",
+      "operator": "=",
+      "left": switchStatement.fallthroughId,
+      "right": {
+        "type": "Literal",
+        "value": 1
+      }
+    };
+    return this;
+  };
+  FallthroughStatement.getNextVariableName = function() {
+    if (!(typeof this.fallthroughIndex !== "undefined" && this.fallthroughIndex !== null)) {
+      this.fallthroughIndex = 0;
+    }
+    return "fallthrough" + this.fallthroughIndex++;
+  };
+  FallthroughStatement.resetVariableNames = function() {
+    this.fallthroughIndex = 0;
+  };
+  exports.FallthroughStatement = FallthroughStatement;
+  return {};
+});
+
+//# sourceMappingURL=FallthroughStatement.map

data/lib/spider-src/support/spider/lib/ast/statements/ForInStatement.js

@@ -0,0 +1,79 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function ForInStatement(item, index, array, body) {
+    Node.call(this);
+    this.type = "ForInStatement";
+    this.item = item;
+    this.item.parent = this;
+    this.index = index;
+    if (typeof this.index !== "undefined" && this.index !== null) {
+      this.index.parent = this;
+    }
+    this.array = array;
+    this.array.parent = this;
+    this.body = body;
+    this.body.parent = this;
+  }
+  ForInStatement.prototype = Object.create(Node);
+  ForInStatement.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.item = this.item.codegen(false);
+    if (typeof this.index !== "undefined" && this.index !== null) {
+      var context = this.getContext();
+      this.index = this.index.codegen(false);
+      context.node.body.splice(context.position, 0, {
+        "type": "VariableDeclaration",
+        "declarations": [{
+          "type": "VariableDeclarator",
+          "id": this.index,
+          "init": {
+            "type": "Literal",
+            "value": 0
+          }
+        }],
+        "kind": "let"
+      });
+    }
+    if (!this.array.codeGenerated) {
+      this.array = this.array.codegen();
+    }
+    this.body = this.body.blockWrap();
+    this.body.defineIdentifier(this.item);
+    if (typeof this.index !== "undefined" && this.index !== null) {
+      this.body.defineIdentifier(this.index);
+    }
+    this.body = this.body.codegen();
+    if (typeof this.index !== "undefined" && this.index !== null) {
+      this.body.body.push({
+        "type": "ExpressionStatement",
+        "codeGenerated": true,
+        "expression": {
+          "type": "UpdateExpression",
+          "operator": "++",
+          "argument": this.index,
+          "prefix": false
+        }
+      });
+    }
+    this.type = "ForOfStatement";
+    this.right = this.array;
+    this.left = {
+      "type": "VariableDeclaration",
+      "declarations": [{
+        "type": "VariableDeclarator",
+        "id": this.item,
+        "init": null
+      }],
+      "kind": "let"
+    };
+    this.each = false;
+    return this;
+  };
+  exports.ForInStatement = ForInStatement;
+  return {};
+});
+
+//# sourceMappingURL=ForInStatement.map

data/lib/spider-src/support/spider/lib/ast/statements/ForOfStatement.js

@@ -0,0 +1,98 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node,
+      ForInStatement = module.require("./ForInStatement").ForInStatement;
+  function ForOfStatement(key, value, object, body) {
+    Node.call(this);
+    this.type = "ForOfStatement";
+    this.key = key;
+    this.key.parent = this;
+    this.value = value;
+    if (typeof this.value !== "undefined" && this.value !== null) {
+      this.value.parent = this;
+    }
+    this.object = object;
+    this.object.parent = this;
+    this.body = body;
+    this.body.parent = this;
+  }
+  ForOfStatement.prototype = Object.create(Node);
+  ForOfStatement.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.object = this.object.codegen();
+    if (typeof this.value !== "undefined" && this.value !== null) {
+      this.value = this.value.codegen(false);
+      this.body.defineIdentifier(this.value);
+      if (this.object.hasCallExpression()) {
+        var id = {
+          "type": "Identifier",
+          "name": exports.ForOfStatement.getNextVariableName()
+        };
+        var context = this.getContext();
+        context.node.body.splice(context.position, 0, {
+          "type": "VariableDeclaration",
+          "declarations": [{
+            "type": "VariableDeclarator",
+            "id": id,
+            "init": this.object
+          }],
+          "kind": "let",
+          "codeGenerated": true
+        });
+        this.object = id;
+      }
+      this.body.body = [{
+        "type": "VariableDeclaration",
+        "codeGenerated": true,
+        "declarations": [{
+          "type": "VariableDeclarator",
+          "id": this.value,
+          "init": {
+            "type": "MemberExpression",
+            "computed": "true",
+            "object": this.object,
+            "property": this.key
+          }
+        }],
+        "kind": "let"
+      }].concat(this.body.body);
+    }
+    var forInLoop = new ForInStatement(this.key, null, {
+      "type": "CallExpression",
+      "codeGenerated": true,
+      "callee": {
+        "type": "MemberExpression",
+        "computed": false,
+        "object": {
+          "type": "Identifier",
+          "name": "Object"
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "keys"
+        }
+      },
+      "arguments": [this.object]
+    }, this.body).codegen();
+    this.type = forInLoop.type;
+    this.right = forInLoop.right;
+    this.left = forInLoop.left;
+    this.each = forInLoop.each;
+    return this;
+  };
+  ForOfStatement.getNextVariableName = function() {
+    if (!this.forOfIndex) {
+      this.forOfIndex = 0;
+    }
+    return "forOf" + this.forOfIndex++;
+  };
+  ForOfStatement.resetVariableNames = function() {
+    this.forOfIndex = 0;
+  };
+  exports.ForOfStatement = ForOfStatement;
+  return {};
+});
+
+//# sourceMappingURL=ForOfStatement.map

data/lib/spider-src/support/spider/lib/ast/statements/ForStatement.js

@@ -0,0 +1,43 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function ForStatement(init, test, update, body) {
+    Node.call(this);
+    this.type = "ForStatement";
+    this.init = init;
+    if (typeof this.init !== "undefined" && this.init !== null) {
+      this.init.parent = this;
+    }
+    this.test = test;
+    if (typeof this.test !== "undefined" && this.test !== null) {
+      this.test.parent = this;
+    }
+    this.update = update;
+    if (typeof this.update !== "undefined" && this.update !== null) {
+      this.update.parent = this;
+    }
+    this.body = body;
+    this.body.parent = this;
+  }
+  ForStatement.prototype = Object.create(Node);
+  ForStatement.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    if (typeof this.init !== "undefined" && this.init !== null) {
+      this.init = this.init.codegen();
+    }
+    if (typeof this.test !== "undefined" && this.test !== null) {
+      this.test = this.test.codegen();
+    }
+    if (typeof this.update !== "undefined" && this.update !== null) {
+      this.update = this.update.codegen();
+    }
+    this.body = this.body.blockWrap().codegen();
+    return this;
+  };
+  exports.ForStatement = ForStatement;
+  return {};
+});
+
+//# sourceMappingURL=ForStatement.map

data/lib/spider-src/support/spider/lib/ast/statements/FunctionDeclarationStatement.js

@@ -0,0 +1,104 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node,
+      Parameter = module.require("../Parameter").Parameter,
+      CallExpression = module.require("../expressions/CallExpression").CallExpression;
+  function FunctionDeclarationStatement(id, params, body, inheritsFrom) {
+    Node.call(this);
+    this.type = "FunctionDeclaration";
+    this.defaults = [];
+    this.rest = null;
+    this.generator = false;
+    this.expression = false;
+    this.id = id;
+    this.id.parent = this;
+    this.body = body;
+    this.body.parent = this;
+    this.params = params;
+    for (var $__0 = params[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var param = $__1.value;
+      {
+        param.parent = this;
+      }
+    }
+    this.inheritsFrom = inheritsFrom;
+    if (typeof this.inheritsFrom !== "undefined" && this.inheritsFrom !== null) {
+      this.inheritsFrom.parent = this;
+    }
+  }
+  FunctionDeclarationStatement.prototype = Object.create(Node);
+  FunctionDeclarationStatement.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.id = this.id.codegen();
+    Parameter.generateFunctionBody(this, this.params, this.body, this.defaults);
+    this.body = this.body.codegen();
+    if (typeof this.inheritsFrom !== "undefined" && this.inheritsFrom !== null) {
+      if (this.inheritsFrom.type !== "CallExpression") {
+        this.inheritsFrom = new CallExpression(this.inheritsFrom, []);
+        this.inheritsFrom.parent = this;
+      }
+      this.inheritsFrom = this.inheritsFrom.codegen();
+      this.body.body.splice(0, 0, {
+        "type": "ExpressionStatement",
+        "expression": {
+          "type": "CallExpression",
+          "callee": {
+            "type": "MemberExpression",
+            "computed": false,
+            "object": this.inheritsFrom.callee,
+            "property": {
+              "type": "Identifier",
+              "name": "call"
+            }
+          },
+          "arguments": [{"type": "ThisExpression"}].concat(this.inheritsFrom.arguments)
+        }
+      });
+      var context = this.getContext();
+      context.node.body.splice(context.position + 1, 0, {
+        "type": "ExpressionStatement",
+        "codeGenerated": "true",
+        "expression": {
+          "type": "AssignmentExpression",
+          "operator": "=",
+          "left": {
+            "type": "MemberExpression",
+            "computed": false,
+            "object": this.id,
+            "property": {
+              "type": "Identifier",
+              "name": "prototype"
+            }
+          },
+          "right": {
+            "type": "CallExpression",
+            "callee": {
+              "type": "MemberExpression",
+              "computed": false,
+              "object": {
+                "type": "Identifier",
+                "name": "Object"
+              },
+              "property": {
+                "type": "Identifier",
+                "name": "create"
+              }
+            },
+            "arguments": [this.inheritsFrom.callee]
+          }
+        }
+      });
+    }
+    return this;
+  };
+  FunctionDeclarationStatement.prototype.hasCallExpression = function() {
+    return true;
+  };
+  exports.FunctionDeclarationStatement = FunctionDeclarationStatement;
+  return {};
+});
+
+//# sourceMappingURL=FunctionDeclarationStatement.map

data/lib/spider-src/support/spider/lib/ast/statements/GoStatement.js

@@ -0,0 +1,41 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function GoStatement(body) {
+    Node.call(this);
+    this.type = "GoStatement";
+    this.body = body;
+    this.body.parent = this;
+  }
+  GoStatement.prototype = Object.create(Node);
+  GoStatement.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.body = this.body.codegen();
+    this.type = "ExpressionStatement";
+    this.expression = {
+      "type": "CallExpression",
+      "callee": {
+        "type": "UnaryExpression",
+        "operator": "async",
+        "argument": {
+          "type": "FunctionExpression",
+          "id": null,
+          "params": [],
+          "defaults": [],
+          "body": this.body,
+          "rest": null,
+          "generator": false,
+          "expression": false
+        }
+      },
+      "arguments": []
+    };
+    return this;
+  };
+  exports.GoStatement = GoStatement;
+  return {};
+});
+
+//# sourceMappingURL=GoStatement.map

data/lib/spider-src/support/spider/lib/ast/statements/IfStatement.js

@@ -0,0 +1,32 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function IfStatement(test, consequent, alternate) {
+    Node.call(this);
+    this.type = "IfStatement";
+    this.test = test;
+    this.test.parent = this;
+    this.consequent = consequent;
+    this.consequent.parent = this;
+    this.alternate = alternate;
+    if (typeof this.alternate !== "undefined" && this.alternate !== null) {
+      this.alternate.parent = this;
+    }
+  }
+  IfStatement.prototype = Object.create(Node);
+  IfStatement.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.test = this.test.codegen();
+    this.consequent = this.consequent.blockWrap().codegen();
+    if (typeof this.alternate !== "undefined" && this.alternate !== null) {
+      this.alternate = this.alternate.blockWrap().codegen();
+    }
+    return this;
+  };
+  exports.IfStatement = IfStatement;
+  return {};
+});
+
+//# sourceMappingURL=IfStatement.map

data/lib/spider-src/support/spider/lib/ast/statements/ImportDeclarationStatement.js

@@ -0,0 +1,40 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function ImportDeclarationStatement(specifiers, source, kind) {
+    Node.call(this);
+    this.type = "ImportDeclaration";
+    this.kind = kind;
+    this.specifiers = specifiers;
+    for (var $__0 = this.specifiers[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var specifier = $__1.value;
+      {
+        specifier.parent = this;
+      }
+    }
+    this.source = source;
+    this.source.parent = this;
+  }
+  ImportDeclarationStatement.prototype = Object.create(Node);
+  ImportDeclarationStatement.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var i = 0;
+    for (var $__0 = this.specifiers[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var specifier = $__1.value;
+      {
+        this.specifiers[i] = specifier.codegen();
+        i++;
+      }
+    }
+    this.source = this.source.codegen();
+    return this;
+  };
+  exports.ImportDeclarationStatement = ImportDeclarationStatement;
+  return {};
+});
+
+//# sourceMappingURL=ImportDeclarationStatement.map

data/lib/spider-src/support/spider/lib/ast/statements/PushStatement.js

@@ -0,0 +1,37 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function PushStatement(left, right) {
+    Node.call(this);
+    this.type = "PushStatement";
+    this.left = left;
+    this.left.parent = this;
+    this.right = right;
+    this.right.parent = this;
+  }
+  PushStatement.prototype = Object.create(Node);
+  PushStatement.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.type = "ExpressionStatement";
+    this.expression = {
+      "type": "CallExpression",
+      "callee": {
+        "type": "MemberExpression",
+        "object": this.left.codegen(),
+        "property": {
+          "type": "Identifier",
+          "name": "push"
+        },
+        "computed": false
+      },
+      "arguments": [this.right.codegen()]
+    };
+    return this;
+  };
+  exports.PushStatement = PushStatement;
+  return {};
+});
+
+//# sourceMappingURL=PushStatement.map

data/lib/spider-src/support/spider/lib/ast/statements/ReturnStatement.js

@@ -0,0 +1,26 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function ReturnStatement(argument) {
+    Node.call(this);
+    this.type = "ReturnStatement";
+    this.argument = argument;
+    if (typeof this.argument !== "undefined" && this.argument !== null) {
+      this.argument.parent = this;
+    }
+  }
+  ReturnStatement.prototype = Object.create(Node);
+  ReturnStatement.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    if (typeof this.argument !== "undefined" && this.argument !== null) {
+      this.argument = this.argument.codegen();
+    }
+    return this;
+  };
+  exports.ReturnStatement = ReturnStatement;
+  return {};
+});
+
+//# sourceMappingURL=ReturnStatement.map