spider-src 0.1.5

data/lib/spider-src/support/spider/lib/ast/Parameter.js

@@ -0,0 +1,229 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("./Node").Node;
+  function Parameter(id, defaultValue, splat) {
+    Node.call(this);
+    this.type = "Parameter";
+    this.splat = splat;
+    this.id = id;
+    this.id.parent = this;
+    this.defaultValue = defaultValue;
+    if (typeof this.defaultValue !== "undefined" && this.defaultValue !== null) {
+      this.defaultValue.parent = this;
+    }
+  }
+  Parameter.prototype = Object.create(Node);
+  Parameter.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.id = this.id.codegen(false);
+    if (typeof this.defaultValue !== "undefined" && this.defaultValue !== null) {
+      this.defaultValue = this.defaultValue.codegen();
+    }
+    return this;
+  };
+  Parameter.prototype.hasCallExpression = function() {
+    return false;
+  };
+  Parameter.generateFunctionBody = function(func, params, body, defaults) {
+    var splatPosition = -1;
+    var i = 0;
+    for (var $__0 = params[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var param = $__1.value;
+      {
+        if (param.splat) {
+          if (splatPosition !== -1) {
+            Node.getErrorManager().error({
+              type: "MultipleSplatsDisallowed",
+              message: "multiple splats are disallowed in a function declaration",
+              loc: param.loc
+            });
+          }
+          splatPosition = i;
+        }
+        param = param.codegen();
+        defaults.push(param.defaultValue);
+        params[i] = param.id;
+        func.defineIdentifier(param.id);
+        i++;
+      }
+    }
+    if (splatPosition !== -1) {
+      var declarations = [{
+        "type": "VariableDeclarator",
+        "id": {
+          "type": "Identifier",
+          "name": "__splat"
+        },
+        "init": null
+      }];
+      var i$__4 = 0;
+      for (var $__2 = params[$traceurRuntime.toProperty(Symbol.iterator)](),
+          $__3; !($__3 = $__2.next()).done; ) {
+        var param$__5 = $__3.value;
+        {
+          var init;
+          if (i$__4 < splatPosition) {
+            init = {
+              "type": "MemberExpression",
+              "computed": true,
+              "object": {
+                "type": "Identifier",
+                "name": "arguments"
+              },
+              "property": {
+                "type": "Literal",
+                "value": i$__4
+              }
+            };
+          } else {
+            if (i$__4 === splatPosition) {
+              init = {
+                "type": "ConditionalExpression",
+                "test": {
+                  "type": "BinaryExpression",
+                  "operator": "<=",
+                  "left": {
+                    "type": "Literal",
+                    "value": params.length
+                  },
+                  "right": {
+                    "type": "MemberExpression",
+                    "computed": false,
+                    "object": {
+                      "type": "Identifier",
+                      "name": "arguments"
+                    },
+                    "property": {
+                      "type": "Identifier",
+                      "name": "length"
+                    }
+                  }
+                },
+                "consequent": {
+                  "type": "CallExpression",
+                  "callee": {
+                    "type": "MemberExpression",
+                    "computed": false,
+                    "object": {
+                      "type": "MemberExpression",
+                      "computed": false,
+                      "object": {
+                        "type": "ArrayExpression",
+                        "elements": []
+                      },
+                      "property": {
+                        "type": "Identifier",
+                        "name": "slice"
+                      }
+                    },
+                    "property": {
+                      "type": "Identifier",
+                      "name": "call"
+                    }
+                  },
+                  "arguments": [{
+                    "type": "Identifier",
+                    "name": "arguments"
+                  }, {
+                    "type": "Literal",
+                    "value": splatPosition
+                  }]
+                },
+                "alternate": {
+                  "type": "ArrayExpression",
+                  "elements": []
+                }
+              };
+              if (splatPosition < params.length - 1) {
+                init.consequent.arguments.push({
+                  "type": "AssignmentExpression",
+                  "operator": "=",
+                  "left": {
+                    "type": "Identifier",
+                    "name": "__splat"
+                  },
+                  "right": {
+                    "type": "BinaryExpression",
+                    "operator": "-",
+                    "left": {
+                      "type": "MemberExpression",
+                      "computed": false,
+                      "object": {
+                        "type": "Identifier",
+                        "name": "arguments"
+                      },
+                      "property": {
+                        "type": "Identifier",
+                        "name": "length"
+                      }
+                    },
+                    "right": {
+                      "type": "Literal",
+                      "value": params.length - splatPosition - 1
+                    }
+                  }
+                });
+                init.alternate = {
+                  "type": "SequenceExpression",
+                  "expressions": [{
+                    "type": "AssignmentExpression",
+                    "operator": "=",
+                    "left": {
+                      "type": "Identifier",
+                      "name": "__splat"
+                    },
+                    "right": {
+                      "type": "Literal",
+                      "value": splatPosition
+                    }
+                  }, {
+                    "type": "ArrayExpression",
+                    "elements": []
+                  }]
+                };
+              }
+            } else {
+              init = {
+                "type": "MemberExpression",
+                "computed": true,
+                "object": {
+                  "type": "Identifier",
+                  "name": "arguments"
+                },
+                "property": {
+                  "type": "UpdateExpression",
+                  "operator": "++",
+                  "argument": {
+                    "type": "Identifier",
+                    "name": "__splat"
+                  },
+                  "prefix": false
+                }
+              };
+            }
+          }
+          declarations.push({
+            "type": "VariableDeclarator",
+            "id": param$__5,
+            "init": init
+          });
+          i$__4++;
+        }
+      }
+      body.body = [{
+        "type": "VariableDeclaration",
+        "codeGenerated": true,
+        "declarations": declarations,
+        "kind": "let"
+      }].concat(body.body);
+      params.length = 0;
+    }
+  };
+  exports.Parameter = Parameter;
+  return {};
+});
+
+//# sourceMappingURL=Parameter.map

data/lib/spider-src/support/spider/lib/ast/Program.js

@@ -0,0 +1,58 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("./Node").Node;
+  function Program(body) {
+    Node.call(this);
+    this.type = "Program";
+    this.body = body;
+    var i = 0;
+    for (var $__0 = body[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var statement = $__1.value;
+      {
+        if (typeof statement !== "undefined" && statement !== null) {
+          statement.parent = this;
+        } else {
+          body[i] = {type: "EmptyStatement"};
+        }
+        i++;
+      }
+    }
+    this.definedIdentifiers = Program.prototype.generateIdentifiers("Infinity", "NaN", "eval", "uneval", "isFinite", "isNaN", "parseFloat", "parseInt", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "escape", "unescape", "Object", "Function", "Boolean", "Symbol", "Error", "EvalError", "InternalError", "RangeError", "ReferenceError", "StopIteration", "SyntaxError", "TypeError", "URIError", "Number", "Math", "Date", "String", "RegExp", "Array", "Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array", "Map", "Set", "WeakMap", "WeakSet", "ArrayBuffer", "DataView", "JSON", "Iterator", "Generator", "Promise", "arguments");
+  }
+  Program.prototype = Object.create(Node);
+  Program.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var i = 0;
+    while (i < this.body.length) {
+      var statement = this.body[i];
+      if (!statement || !!statement.codeGenerated) {
+        i++;
+        continue;
+      }
+      if (!!statement.codegen && !!statement.codegen()) {
+        this.body[this.body.indexOf(statement)] = statement;
+        i++;
+      } else {
+        this.body.splice(i, 1);
+      }
+    }
+    return this;
+  };
+  Program.prototype.generateIdentifiers = function() {
+    var __splat,
+        identifiers = 1 <= arguments.length ? [].slice.call(arguments, 0) : [];
+    return identifiers.map(function(id) {
+      return {
+        "type": "Identifier",
+        "name": id
+      };
+    });
+  };
+  exports.Program = Program;
+  return {};
+});
+
+//# sourceMappingURL=Program.map

data/lib/spider-src/support/spider/lib/ast/Property.js

@@ -0,0 +1,32 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("./Node").Node;
+  function Property(key, value, shorthand, method) {
+    Node.call(this);
+    this.type = "Property";
+    this.kind = "init";
+    this.method = method;
+    this.shorthand = shorthand;
+    this.computed = false;
+    this.key = key;
+    this.key.parent = this;
+    this.value = value;
+    this.value.parent = this;
+  }
+  Property.prototype = Object.create(Node);
+  Property.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.key = this.key.codegen(false);
+    this.value = this.value.codegen(this.parent.type !== "ObjectPattern");
+    return this;
+  };
+  Property.prototype.hasCallExpression = function() {
+    return this.value.hasCallExpression();
+  };
+  exports.Property = Property;
+  return {};
+});
+
+//# sourceMappingURL=Property.map

data/lib/spider-src/support/spider/lib/ast/Range.js

@@ -0,0 +1,257 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("./Node").Node;
+  function Range(start, operator, to) {
+    Node.call(this);
+    this.type = "Range";
+    this.operator = operator;
+    this.start = start;
+    if (typeof this.start !== "undefined" && this.start !== null) {
+      this.start.parent = this;
+    }
+    this.to = to;
+    if (typeof this.to !== "undefined" && this.to !== null) {
+      this.to.parent = this;
+    }
+  }
+  Range.prototype = Object.create(Node);
+  Range.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var isNumber = function(n) {
+      return !isNaN(parseFloat(n)) && !!isFinite(n);
+    };
+    var isNumeric = !!isNumber(this.start.value) && !!isNumber(this.to.value);
+    this.start = this.start.codegen();
+    this.to = this.to.codegen();
+    var updateOperator,
+        testOperator;
+    if (isNumeric) {
+      updateOperator = this.start.value < this.to.value ? "++" : "--";
+      testOperator = this.start.value < this.to.value ? "<" : ">";
+      if (this.operator === "..") {
+        testOperator += "=";
+      }
+    }
+    if (!!isNumeric && !!(Math.abs(this.to.value - this.start.value) <= 20)) {
+      this.type = "ArrayExpression";
+      this.elements = [];
+      var test = function(i) {
+        if (testOperator === ">") {
+          return i > this.to.value;
+        } else if (testOperator === "<") {
+          return i < this.to.value;
+        } else if (testOperator === ">=") {
+          return i >= this.to.value;
+        } else if (testOperator === "<=") {
+          return i <= this.to.value;
+        }
+      };
+      for (var i = this.start.value; test.call(this, i); updateOperator === "++" ? i++ : i--) {
+        this.elements.push({
+          "type": "Literal",
+          "value": i
+        });
+      }
+    } else {
+      var testExpression,
+          updateExpression;
+      var declarations = [{
+        "type": "VariableDeclarator",
+        "id": {
+          "type": "Identifier",
+          "name": "_results"
+        },
+        "init": {
+          "type": "ArrayExpression",
+          "elements": []
+        }
+      }];
+      if (isNumeric) {
+        testExpression = {
+          "type": "BinaryExpression",
+          "operator": testOperator,
+          "left": {
+            "type": "Identifier",
+            "name": "_i"
+          },
+          "right": this.to
+        };
+        updateExpression = {
+          "type": "UpdateExpression",
+          "operator": updateOperator,
+          "argument": {
+            "type": "Identifier",
+            "name": "_i"
+          },
+          "prefix": false
+        };
+      } else {
+        if (this.start.hasCallExpression()) {
+          var startId = {
+            "type": "Identifier",
+            "name": "_start"
+          };
+          declarations.push({
+            "type": "VariableDeclarator",
+            "id": startId,
+            "init": this.start
+          });
+          this.start = startId;
+        }
+        if (this.to.hasCallExpression()) {
+          var endId = {
+            "type": "Identifier",
+            "name": "_end"
+          };
+          declarations.push({
+            "type": "VariableDeclarator",
+            "id": endId,
+            "init": this.to
+          });
+          this.to = endId;
+        }
+        testExpression = {
+          "type": "ConditionalExpression",
+          "test": {
+            "type": "BinaryExpression",
+            "operator": "<=",
+            "left": this.start,
+            "right": this.to
+          },
+          "consequent": {
+            "type": "BinaryExpression",
+            "operator": "<" + (this.operator === ".." ? "=" : ""),
+            "left": {
+              "type": "Identifier",
+              "name": "_i"
+            },
+            "right": this.to
+          },
+          "alternate": {
+            "type": "BinaryExpression",
+            "operator": ">" + (this.operator === ".." ? "=" : ""),
+            "left": {
+              "type": "Identifier",
+              "name": "_i"
+            },
+            "right": this.to
+          }
+        };
+        updateExpression = {
+          "type": "ConditionalExpression",
+          "test": {
+            "type": "BinaryExpression",
+            "operator": "<=",
+            "left": this.start,
+            "right": this.to
+          },
+          "consequent": {
+            "type": "UpdateExpression",
+            "operator": "++",
+            "argument": {
+              "type": "Identifier",
+              "name": "_i"
+            },
+            "prefix": false
+          },
+          "alternate": {
+            "type": "UpdateExpression",
+            "operator": "--",
+            "argument": {
+              "type": "Identifier",
+              "name": "_i"
+            },
+            "prefix": false
+          }
+        };
+      }
+      this.type = "CallExpression";
+      this.callee = {
+        "type": "MemberExpression",
+        "computed": false,
+        "object": {
+          "type": "FunctionExpression",
+          "id": null,
+          "params": [],
+          "defaults": [],
+          "body": {
+            "type": "BlockStatement",
+            "body": [{
+              "type": "VariableDeclaration",
+              "declarations": declarations,
+              "kind": "let"
+            }, {
+              "type": "ForStatement",
+              "init": {
+                "type": "VariableDeclaration",
+                "declarations": [{
+                  "type": "VariableDeclarator",
+                  "id": {
+                    "type": "Identifier",
+                    "name": "_i"
+                  },
+                  "init": this.start
+                }],
+                "kind": "let"
+              },
+              "test": testExpression,
+              "update": updateExpression,
+              "body": {
+                "type": "BlockStatement",
+                "body": [{
+                  "type": "ExpressionStatement",
+                  "expression": {
+                    "type": "CallExpression",
+                    "callee": {
+                      "type": "MemberExpression",
+                      "computed": false,
+                      "object": {
+                        "type": "Identifier",
+                        "name": "_results"
+                      },
+                      "property": {
+                        "type": "Identifier",
+                        "name": "push"
+                      }
+                    },
+                    "arguments": [{
+                      "type": "Identifier",
+                      "name": "_i"
+                    }]
+                  }
+                }]
+              }
+            }, {
+              "type": "ReturnStatement",
+              "argument": {
+                "type": "Identifier",
+                "name": "_results"
+              }
+            }]
+          },
+          "rest": null,
+          "generator": false,
+          "expression": false
+        },
+        "property": {
+          "type": "Identifier",
+          "name": "apply"
+        }
+      };
+      Object.defineProperty(this, "arguments", {
+        value: [{"type": "ThisExpression"}],
+        enumerable: true
+      });
+    }
+    return this;
+  };
+  Range.prototype.hasCallExpression = function() {
+    return true;
+  };
+  exports.Range = Range;
+  return {};
+});
+
+//# sourceMappingURL=Range.map

data/lib/spider-src/support/spider/lib/ast/VariableDeclarator.js

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

data/lib/spider-src/support/spider/lib/ast/expressions/ArrayExpression.js

@@ -0,0 +1,41 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function ArrayExpression(elements) {
+    Node.call(this);
+    this.type = "ArrayExpression";
+    this.elements = elements;
+    for (var $__0 = this.elements[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var element = $__1.value;
+      {
+        if (typeof element !== "undefined" && element !== null) {
+          element.parent = this;
+        }
+      }
+    }
+  }
+  ArrayExpression.prototype = Object.create(Node);
+  ArrayExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var i = 0;
+    for (var $__0 = this.elements[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var element = $__1.value;
+      {
+        this.elements[i] = typeof element !== "undefined" && element !== null ? element.codegen() : void 0;
+        i++;
+      }
+    }
+    return this;
+  };
+  ArrayExpression.prototype.hasCallExpression = function() {
+    return true;
+  };
+  exports.ArrayExpression = ArrayExpression;
+  return {};
+});
+
+//# sourceMappingURL=ArrayExpression.map

data/lib/spider-src/support/spider/lib/ast/expressions/ArrayPattern.js

@@ -0,0 +1,45 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function ArrayPattern(elements) {
+    Node.call(this);
+    this.type = "ArrayPattern";
+    this.elements = elements;
+    for (var $__0 = this.elements[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var element = $__1.value;
+      {
+        if (typeof element !== "undefined" && element !== null) {
+          element.parent = this;
+        }
+      }
+    }
+  }
+  ArrayPattern.prototype = Object.create(Node);
+  ArrayPattern.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var context = this.getContext().node;
+    var i = 0;
+    for (var $__0 = this.elements[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var element = $__1.value;
+      {
+        this.elements[i] = typeof element !== "undefined" && element !== null ? element.codegen(false) : void 0;
+        if (!!(typeof element !== "undefined" && element !== null) && !!(element.type === "Identifier")) {
+          context.defineIdentifier(element);
+        }
+        i++;
+      }
+    }
+    return this;
+  };
+  ArrayPattern.prototype.hasCallExpression = function() {
+    return true;
+  };
+  exports.ArrayPattern = ArrayPattern;
+  return {};
+});
+
+//# sourceMappingURL=ArrayPattern.map