spider-src 0.1.5

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

@@ -0,0 +1,147 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function UnaryExpression(operator, argument) {
+    Node.call(this);
+    this.type = "UnaryExpression";
+    this.operator = operator;
+    this.argument = argument;
+    this.argument.parent = this;
+    this.prefix = true;
+  }
+  UnaryExpression.prototype = Object.create(Node);
+  UnaryExpression.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.argument = this.argument.codegen();
+    if (this.operator === "typeof") {
+      var typeofExpression = {
+        "type": "CallExpression",
+        "callee": {
+          "type": "MemberExpression",
+          "computed": false,
+          "object": {
+            "type": "MemberExpression",
+            "computed": true,
+            "object": {
+              "type": "CallExpression",
+              "callee": {
+                "type": "MemberExpression",
+                "computed": false,
+                "object": {
+                  "type": "CallExpression",
+                  "callee": {
+                    "type": "MemberExpression",
+                    "computed": false,
+                    "object": {
+                      "type": "MemberExpression",
+                      "computed": false,
+                      "object": {
+                        "type": "ObjectExpression",
+                        "properties": []
+                      },
+                      "property": {
+                        "type": "Identifier",
+                        "name": "toString"
+                      }
+                    },
+                    "property": {
+                      "type": "Identifier",
+                      "name": "call"
+                    }
+                  },
+                  "arguments": [this.argument]
+                },
+                "property": {
+                  "type": "Identifier",
+                  "name": "match"
+                }
+              },
+              "arguments": [{
+                "type": "Literal",
+                "value": new RegExp("\\s([a-zA-Z]+)")
+              }]
+            },
+            "property": {
+              "type": "Literal",
+              "value": 1,
+              "raw": "1"
+            }
+          },
+          "property": {
+            "type": "Identifier",
+            "name": "toLowerCase"
+          }
+        },
+        "arguments": []
+      };
+      if (!this.argument.hasCallExpression()) {
+        this.type = "ConditionalExpression";
+        this.test = {
+          "type": "BinaryExpression",
+          "operator": "===",
+          "left": {
+            "type": "UnaryExpression",
+            "operator": "typeof",
+            "argument": this.argument,
+            "prefix": true
+          },
+          "right": {
+            "type": "Literal",
+            "value": "undefined",
+            "raw": "'undefined'"
+          }
+        };
+        this.consequent = {
+          "type": "Literal",
+          "value": "undefined"
+        };
+        this.alternate = typeofExpression;
+      } else {
+        this.type = typeofExpression.type;
+        this.callee = typeofExpression.callee;
+        Object.defineProperty(this, "arguments", {
+          value: typeofExpression.arguments,
+          enumerable: true
+        });
+      }
+    } else {
+      if (this.operator === "<-") {
+        var parent = this.parent;
+        while (!!(!!(typeof parent !== "undefined" && parent !== null) && !!(parent.type !== "FunctionExpression")) && !!(parent.type !== "GoStatement")) {
+          parent = parent.parent;
+        }
+        if (!(typeof parent !== "undefined" && parent !== null) || !!(!!(parent.type !== "GoStatement") && !!(!!(parent.parent.type !== "UnaryExpression") || !!(parent.parent.operator !== "async")))) {
+          Node.getErrorManager().error({
+            type: "GetExpressionRequiresAsync",
+            message: "unary <- must be in a go statement or an async function",
+            loc: this.loc
+          });
+        }
+        this.operator = "await";
+        this.argument = {
+          "type": "CallExpression",
+          "callee": {
+            "type": "MemberExpression",
+            "object": this.argument,
+            "property": {
+              "type": "Identifier",
+              "name": "get"
+            },
+            "computed": false
+          },
+          "arguments": []
+        };
+      }
+    }
+    return this;
+  };
+  UnaryExpression.prototype.hasCallExpression = function() {
+    return typeof this.argument !== "undefined" && this.argument !== null ? this.argument.hasCallExpression() : void 0;
+  };
+  exports.UnaryExpression = UnaryExpression;
+  return {};
+});
+
+//# sourceMappingURL=UnaryExpression.map

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

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

data/lib/spider-src/support/spider/lib/ast/literals/BooleanLiteral.js

@@ -0,0 +1,24 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function BooleanLiteral(text) {
+    Node.call(this);
+    this.type = "Literal";
+    this.value = text === "true";
+    this.raw = text;
+  }
+  BooleanLiteral.prototype = Object.create(Node);
+  BooleanLiteral.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    return this;
+  };
+  BooleanLiteral.prototype.hasCallExpression = function() {
+    return false;
+  };
+  exports.BooleanLiteral = BooleanLiteral;
+  return {};
+});
+
+//# sourceMappingURL=BooleanLiteral.map

data/lib/spider-src/support/spider/lib/ast/literals/Identifier.js

@@ -0,0 +1,60 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function Identifier(name) {
+    Node.call(this);
+    this.type = "Identifier";
+    this.global = false;
+    Object.defineProperty(this, "name", {
+      value: name,
+      enumerable: true
+    });
+  }
+  Identifier.prototype = Object.create(Node);
+  Identifier.prototype.codegen = function() {
+    var undefinedCheck = arguments[0] !== (void 0) ? arguments[0] : true;
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    if (!!undefinedCheck && !this.global) {
+      var inExpression1 = ["FunctionDeclaration", "VariableDeclarator"];
+      if (!(!!(inExpression1 instanceof Array ? inExpression1.indexOf(typeof this.parent !== "undefined" && this.parent !== null ? this.parent.type : void 0) !== -1 : (typeof this.parent !== "undefined" && this.parent !== null ? this.parent.type : void 0) in inExpression1) && !!(this.parent.id === this))) {
+        if (!this.parent.isIdentifierDefined(this.name)) {
+          Node.getErrorManager().error({
+            type: "UndefinedIdentifier",
+            identifier: this.name,
+            message: "undefined " + this.name,
+            loc: this.loc
+          });
+        }
+      } else {
+        if (this.parent.isIdentifierDefined(this.name)) {
+          Node.getErrorManager().error({
+            type: "AlreadyDefinedIdentifier",
+            identifier: this.name,
+            message: this.name + " is already defined",
+            loc: this.loc
+          });
+        } else {
+          this.parent.getContext().node.defineIdentifier(this);
+        }
+      }
+    }
+    return this;
+  };
+  Identifier.prototype.hasCallExpression = function() {
+    return false;
+  };
+  Identifier.prototype.asGlobal = function() {
+    this.global = true;
+    return this;
+  };
+  Identifier.prototype.asPredefinedCollection = function() {
+    this.predefinedCollection = true;
+    return this;
+  };
+  exports.Identifier = Identifier;
+  return {};
+});
+
+//# sourceMappingURL=Identifier.map

data/lib/spider-src/support/spider/lib/ast/literals/NullLiteral.js

@@ -0,0 +1,24 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function NullLiteral() {
+    Node.call(this);
+    this.type = "Literal";
+    this.value = null;
+    this.raw = "null";
+  }
+  NullLiteral.prototype = Object.create(Node);
+  NullLiteral.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    return this;
+  };
+  NullLiteral.prototype.hasCallExpression = function() {
+    return false;
+  };
+  exports.NullLiteral = NullLiteral;
+  return {};
+});
+
+//# sourceMappingURL=NullLiteral.map

data/lib/spider-src/support/spider/lib/ast/literals/NumberLiteral.js

@@ -0,0 +1,24 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function NumberLiteral(text) {
+    Node.call(this);
+    this.type = "Literal";
+    this.value = Number(text);
+    this.raw = text;
+  }
+  NumberLiteral.prototype = Object.create(Node);
+  NumberLiteral.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    return this;
+  };
+  NumberLiteral.prototype.hasCallExpression = function() {
+    return false;
+  };
+  exports.NumberLiteral = NumberLiteral;
+  return {};
+});
+
+//# sourceMappingURL=NumberLiteral.map

data/lib/spider-src/support/spider/lib/ast/literals/RegularExpressionLiteral.js

@@ -0,0 +1,25 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function RegularExpressionLiteral(pattern, flags) {
+    Node.call(this);
+    this.type = "Literal";
+    this.pattern = pattern;
+    this.flags = flags;
+  }
+  RegularExpressionLiteral.prototype = Object.create(Node);
+  RegularExpressionLiteral.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.value = new RegExp(this.pattern, this.flags);
+    return this;
+  };
+  RegularExpressionLiteral.prototype.hasCallExpression = function() {
+    return false;
+  };
+  exports.RegularExpressionLiteral = RegularExpressionLiteral;
+  return {};
+});
+
+//# sourceMappingURL=RegularExpressionLiteral.map

data/lib/spider-src/support/spider/lib/ast/literals/StringLiteral.js

@@ -0,0 +1,90 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function StringLiteral(chars, column) {
+    Node.call(this);
+    this.type = "StringLiteral";
+    this.chars = chars;
+    this.column = column;
+  }
+  StringLiteral.prototype = Object.create(Node);
+  StringLiteral.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    var elements = [];
+    for (var $__0 = this.chars[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var value = $__1.value;
+      {
+        var lastElement;
+        if ((typeof value === "undefined" ? "undefined" : {}.toString.call(value).match(/\s([a-zA-Z]+)/)[1].toLowerCase()) === "string") {
+          lastElement = elements[elements.length - 1];
+          if ((typeof lastElement !== "undefined" && lastElement !== null ? lastElement.type : void 0) === "Literal") {
+            lastElement.value += value;
+          } else {
+            elements.push({
+              type: "Literal",
+              value: value
+            });
+          }
+        } else {
+          if ((typeof value !== "undefined" && value !== null ? value.type : void 0) === "StringLiteralNewLine") {
+            lastElement = elements[elements.length - 1];
+            if ((typeof lastElement !== "undefined" && lastElement !== null ? lastElement.type : void 0) === "Literal") {
+              lastElement.value += value.toString(this.column - 1);
+            } else {
+              elements.push({
+                type: "Literal",
+                value: value.toString(this.column - 1)
+              });
+            }
+          } else {
+            value.parent = this;
+            elements.push(value.codegen());
+          }
+        }
+      }
+    }
+    if (elements.length === 0) {
+      return {
+        "type": "Literal",
+        "value": ""
+      };
+    } else {
+      if (elements.length === 1) {
+        return elements[0];
+      }
+    }
+    var reduced = elements.reduce(function(left, right) {
+      return {
+        type: "BinaryExpression",
+        operator: "+",
+        left: left,
+        right: right
+      };
+    });
+    this.type = reduced.type;
+    this.operator = reduced.operator;
+    this.left = reduced.left;
+    this.right = reduced.right;
+    return this;
+  };
+  StringLiteral.prototype.hasCallExpression = function() {
+    return false;
+  };
+  StringLiteral.NewLine = function(text) {
+    this.type = "StringLiteralNewLine";
+    this.toString = function(column) {
+      var t = text.replace(/\r\n/g, "").replace(/\t/g, "    ");
+      if (t.length < column) {
+        return "";
+      }
+      return t.substring(column);
+    };
+  };
+  exports.StringLiteral = StringLiteral;
+  return {};
+});
+
+//# sourceMappingURL=StringLiteral.map

data/lib/spider-src/support/spider/lib/ast/literals/UndefinedLiteral.js

@@ -0,0 +1,30 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function UndefinedLiteral() {
+    Node.call(this);
+    this.type = "UndefinedLiteral";
+  }
+  UndefinedLiteral.prototype = Object.create(Node);
+  UndefinedLiteral.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    this.type = "UnaryExpression";
+    this.operator = "void";
+    this.argument = {
+      "type": "Literal",
+      "value": 0,
+      "raw": "0"
+    };
+    this.prefix = true;
+    return this;
+  };
+  UndefinedLiteral.prototype.hasCallExpression = function() {
+    return false;
+  };
+  exports.UndefinedLiteral = UndefinedLiteral;
+  return {};
+});
+
+//# sourceMappingURL=UndefinedLiteral.map

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

@@ -0,0 +1,47 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function BlockStatement(body) {
+    Node.call(this);
+    this.type = "BlockStatement";
+    this.body = body;
+    var i = 0;
+    for (var $__0 = body[$traceurRuntime.toProperty(Symbol.iterator)](),
+        $__1; !($__1 = $__0.next()).done; ) {
+      var statement = $__1.value;
+      {
+        if (statement) {
+          statement.parent = this;
+        } else {
+          body[i] = {type: "EmptyStatement"};
+        }
+        i++;
+      }
+    }
+  }
+  BlockStatement.prototype = Object.create(Node);
+  BlockStatement.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 (typeof statement.codegen === "function" ? statement.codegen() : void 0) {
+        this.body[this.body.indexOf(statement)] = statement;
+        i++;
+      } else {
+        this.body.splice(i, 1);
+      }
+    }
+    return this;
+  };
+  exports.BlockStatement = BlockStatement;
+  return {};
+});
+
+//# sourceMappingURL=BlockStatement.map

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,51 @@
+$traceurRuntime.ModuleStore.getAnonymousModule(function() {
+  "use strict";
+  var Node = module.require("../Node").Node;
+  function ExportDeclarationStatement(specifiers, source, declaration, isDefault) {
+    Node.call(this);
+    this.type = "ExportDeclaration";
+    this["default"] = isDefault;
+    this.specifiers = specifiers;
+    if (typeof specifiers !== "undefined" && specifiers !== null) {
+      for (var $__0 = this.specifiers[$traceurRuntime.toProperty(Symbol.iterator)](),
+          $__1; !($__1 = $__0.next()).done; ) {
+        var specifier = $__1.value;
+        {
+          specifier.parent = this;
+        }
+      }
+    }
+    this.source = source;
+    if (typeof source !== "undefined" && source !== null) {
+      this.source.parent = this;
+    }
+    this.declaration = declaration;
+    if (typeof declaration !== "undefined" && declaration !== null) {
+      this.declaration.parent = this;
+    }
+  }
+  ExportDeclarationStatement.prototype = Object.create(Node);
+  ExportDeclarationStatement.prototype.codegen = function() {
+    if (!Node.prototype.codegen.call(this)) {
+      return;
+    }
+    if (typeof this.specifiers !== "undefined" && this.specifiers !== null) {
+      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 = typeof this.source !== "undefined" && this.source !== null ? this.source.codegen() : void 0;
+    this.declaration = typeof this.declaration !== "undefined" && this.declaration !== null ? this.declaration.codegen() : void 0;
+    return this;
+  };
+  exports.ExportDeclarationStatement = ExportDeclarationStatement;
+  return {};
+});
+
+//# sourceMappingURL=ExportDeclarationStatement.map

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

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