first commit

themes/ceras/node_modules/regenerator-6to5/.npmignore

@@ -0,0 +1,2 @@
+/node_modules
+/test

themes/ceras/node_modules/regenerator-6to5/.travis.yml

@@ -0,0 +1,7 @@
+language: node_js
+node_js:
+  - "0.11"
+  - "0.10"
+  - "0.8"
+before_install:
+  - npm install -g npm@1.4.28

themes/ceras/node_modules/regenerator-6to5/CONTRIBUTING.md

@@ -0,0 +1,80 @@
+# Contributing to Regenerator
+
+Regenerator uses GitHub as its sole source of truth. Everything happens
+here. Facebook employees who contribute to Regenerator are expected to do
+so in the same way as everyone else. In other words, this document applies
+equally to all contributors.
+
+### `master` is unsafe
+
+We will do our best to keep `master` in good shape, with tests passing at
+all times. But in order to move fast, we will make API changes that your
+application might not be compatible with. We will do our best to
+communicate these changes and always version appropriately so you can lock
+into a specific version if need be.
+
+### Pull Requests
+
+In case you've never submitted a pull request (PR) via GitHub before,
+please read [this short
+tutorial](https://help.github.com/articles/creating-a-pull-request). If
+you've submitted a PR before, there should be nothing surprising about our
+procedures for Regenerator.
+
+*Before* submitting a pull request, please make sure the following is done…
+
+1. Fork the repo and create your branch from `master`.
+2. If you've added code that should be tested, add tests!
+3. Ensure the test suite passes (`npm test`).
+4. If you haven't already, complete the CLA.
+5. Submit a pull request via GitHub.
+6. Check that Travis CI tests pass (pull request turns green).
+
+### Contributor License Agreement ("CLA")
+
+In order to accept your pull request, we need you to submit a CLA. You
+only need to do this once, so if you've done this for another Facebook
+open source project, you're good to go. If you are submitting a pull
+request for the first time, just let us know that you have completed the
+CLA and we can cross-check with your GitHub username.
+
+Complete your CLA here: <https://code.facebook.com/cla>
+
+## Bugs
+
+### Where to Find Known Issues
+
+We will be using GitHub Issues for all bugs. Before filing a new issue,
+please try to make sure your problem doesn't already exist. If you think
+your issue is more general than one that already exists, our preference is
+still to modify the original issue to reflect the underlying problem more
+faithfully.
+
+### Reporting New Issues
+
+The best way to get a bug fixed is to provide a reduced test case, and the
+easiest way to reduce a testcase is to edit it in [the
+sandbox](http://facebook.github.io/regenerator/) until you're satisfied
+and then click the "report a bug" link (the new issue will be populated
+automatically with your code).
+
+### Security Bugs
+
+Facebook has a [bounty program](https://www.facebook.com/whitehat/) for
+the safe disclosure of security bugs. With that in mind, please do not
+file public issues and go through the process outlined on that page.
+
+## Coding Style
+
+* Use semicolons;
+* Commas last,
+* 2 spaces for indentation (no tabs).
+* Prefer `"` over `'`
+* 80 character line length
+* Match surrounding coding style.
+* Less code is better code.
+
+## License
+
+By contributing to Regenerator, you agree that your contributions will be
+licensed under the [BSD License](LICENSE).

themes/ceras/node_modules/regenerator-6to5/LICENSE

@@ -0,0 +1,14 @@
+BSD License
+
+For "regenerator" software
+
+Copyright (c) 2014, Facebook, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+	*	Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+	*	Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

themes/ceras/node_modules/regenerator-6to5/PATENTS

@@ -0,0 +1,7 @@
+Additional Grant of Patent Rights
+
+“Software” means the "regenerator" software distributed by Facebook, Inc.
+
+Facebook hereby grants you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable (subject to the termination provision below) license under any rights in any patent claims owned by Facebook, to make, have made, use, sell, offer to sell, import, and otherwise transfer the Software. For avoidance of doubt, no license is granted under Facebook’s rights in any patent claims that are infringed by (i) modifications to the Software made by you or a third party, or (ii) the Software in combination with any software or other technology provided by you or a third party.
+
+The license granted hereunder will terminate, automatically and without notice, for anyone that makes any claim (including by filing any lawsuit, assertion or other action) alleging (a) direct, indirect, or contributory infringement or inducement to infringe any patent: (i) by Facebook or any of its subsidiaries or affiliates, whether or not such claim is related to the Software, (ii) by any party if such claim arises in whole or in part from any software, product or service of Facebook or any of its subsidiaries or affiliates, whether or not such claim is related to the Software, or (iii) by any party relating to the Software; or (b) that any right in any patent claim of Facebook is invalid or unenforceable.

themes/ceras/node_modules/regenerator-6to5/README.md

@@ -0,0 +1,4 @@
+# regenerator-6to5
+
+**regenerator-6to5** is not supported outside of 6to5 usage. Do not expect support
+if you use this in your own applications.

themes/ceras/node_modules/regenerator-6to5/bin/regenerator

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+// -*- mode: js -*-
+
+var compile = require("../main").compile;
+
+require("commoner").version(
+  require("../package.json").version
+).resolve(function(id) {
+  return this.readModuleP(id);
+}).option(
+  "-r, --include-runtime",
+  "Prepend the runtime to the output."
+).option(
+  "--disable-async",
+  "Disable transformation of async functions."
+).process(function(id, source) {
+  return compile(source, {
+    includeRuntime: this.options.includeRuntime,
+    disableAsync: this.options.disableAsync
+  }).code;
+});

themes/ceras/node_modules/regenerator-6to5/lib/hoist.js

@@ -0,0 +1,153 @@
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var types = require("ast-types");
+var n = types.namedTypes;
+var b = types.builders;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+// The hoist function takes a FunctionExpression or FunctionDeclaration
+// and replaces any Declaration nodes in its body with assignments, then
+// returns a VariableDeclaration containing just the names of the removed
+// declarations.
+exports.hoist = function(funPath) {
+  assert.ok(funPath instanceof types.NodePath);
+  n.Function.assert(funPath.value);
+
+  var vars = {};
+
+  function varDeclToExpr(vdec, includeIdentifiers) {
+    n.VariableDeclaration.assert(vdec);
+    var exprs = [];
+
+    vdec.declarations.forEach(function(dec) {
+      vars[dec.id.name] = dec.id;
+
+      if (dec.init) {
+        exprs.push(b.assignmentExpression(
+          "=", dec.id, dec.init
+        ));
+      } else if (includeIdentifiers) {
+        exprs.push(dec.id);
+      }
+    });
+
+    if (exprs.length === 0)
+      return null;
+
+    if (exprs.length === 1)
+      return exprs[0];
+
+    return b.sequenceExpression(exprs);
+  }
+
+  types.visit(funPath.get("body"), {
+    visitVariableDeclaration: function(path) {
+      var expr = varDeclToExpr(path.value, false);
+      if (expr === null) {
+        path.replace();
+      } else {
+        // We don't need to traverse this expression any further because
+        // there can't be any new declarations inside an expression.
+        return b.expressionStatement(expr);
+      }
+
+      // Since the original node has been either removed or replaced,
+      // avoid traversing it any further.
+      return false;
+    },
+
+    visitForStatement: function(path) {
+      var init = path.value.init;
+      if (n.VariableDeclaration.check(init)) {
+        path.get("init").replace(varDeclToExpr(init, false));
+      }
+      this.traverse(path);
+    },
+
+    visitForInStatement: function(path) {
+      var left = path.value.left;
+      if (n.VariableDeclaration.check(left)) {
+        path.get("left").replace(varDeclToExpr(left, true));
+      }
+      this.traverse(path);
+    },
+
+    visitFunctionDeclaration: function(path) {
+      var node = path.value;
+      vars[node.id.name] = node.id;
+
+      var parentNode = path.parent.node;
+      var assignment = b.expressionStatement(
+        b.assignmentExpression(
+          "=",
+          node.id,
+          b.functionExpression(
+            node.id,
+            node.params,
+            node.body,
+            node.generator,
+            node.expression
+          )
+        )
+      );
+
+      if (n.BlockStatement.check(path.parent.node)) {
+        // Insert the assignment form before the first statement in the
+        // enclosing block.
+        path.parent.get("body").unshift(assignment);
+
+        // Remove the function declaration now that we've inserted the
+        // equivalent assignment form at the beginning of the block.
+        path.replace();
+
+      } else {
+        // If the parent node is not a block statement, then we can just
+        // replace the declaration with the equivalent assignment form
+        // without worrying about hoisting it.
+        path.replace(assignment);
+      }
+
+      // Don't hoist variables out of inner functions.
+      return false;
+    },
+
+    visitFunctionExpression: function(path) {
+      // Don't descend into nested function expressions.
+      return false;
+    }
+  });
+
+  var paramNames = {};
+  funPath.get("params").each(function(paramPath) {
+    var param = paramPath.value;
+    if (n.Identifier.check(param)) {
+      paramNames[param.name] = param;
+    } else {
+      // Variables declared by destructuring parameter patterns will be
+      // harmlessly re-declared.
+    }
+  });
+
+  var declarations = [];
+
+  Object.keys(vars).forEach(function(name) {
+    if (!hasOwn.call(paramNames, name)) {
+      declarations.push(b.variableDeclarator(vars[name], null));
+    }
+  });
+
+  if (declarations.length === 0) {
+    return null; // Be sure to handle this case!
+  }
+
+  return b.variableDeclaration("var", declarations);
+};

themes/ceras/node_modules/regenerator-6to5/lib/leap.js

@@ -0,0 +1,177 @@
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var types = require("ast-types");
+var n = types.namedTypes;
+var b = types.builders;
+var inherits = require("util").inherits;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+function Entry() {
+  assert.ok(this instanceof Entry);
+}
+
+function FunctionEntry(returnLoc) {
+  Entry.call(this);
+  n.Literal.assert(returnLoc);
+  this.returnLoc = returnLoc;
+}
+
+inherits(FunctionEntry, Entry);
+exports.FunctionEntry = FunctionEntry;
+
+function LoopEntry(breakLoc, continueLoc, label) {
+  Entry.call(this);
+
+  n.Literal.assert(breakLoc);
+  n.Literal.assert(continueLoc);
+
+  if (label) {
+    n.Identifier.assert(label);
+  } else {
+    label = null;
+  }
+
+  this.breakLoc = breakLoc;
+  this.continueLoc = continueLoc;
+  this.label = label;
+}
+
+inherits(LoopEntry, Entry);
+exports.LoopEntry = LoopEntry;
+
+function SwitchEntry(breakLoc) {
+  Entry.call(this);
+  n.Literal.assert(breakLoc);
+  this.breakLoc = breakLoc;
+}
+
+inherits(SwitchEntry, Entry);
+exports.SwitchEntry = SwitchEntry;
+
+function TryEntry(firstLoc, catchEntry, finallyEntry) {
+  Entry.call(this);
+
+  n.Literal.assert(firstLoc);
+
+  if (catchEntry) {
+    assert.ok(catchEntry instanceof CatchEntry);
+  } else {
+    catchEntry = null;
+  }
+
+  if (finallyEntry) {
+    assert.ok(finallyEntry instanceof FinallyEntry);
+  } else {
+    finallyEntry = null;
+  }
+
+  // Have to have one or the other (or both).
+  assert.ok(catchEntry || finallyEntry);
+
+  this.firstLoc = firstLoc;
+  this.catchEntry = catchEntry;
+  this.finallyEntry = finallyEntry;
+}
+
+inherits(TryEntry, Entry);
+exports.TryEntry = TryEntry;
+
+function CatchEntry(firstLoc, paramId) {
+  Entry.call(this);
+
+  n.Literal.assert(firstLoc);
+  n.Identifier.assert(paramId);
+
+  this.firstLoc = firstLoc;
+  this.paramId = paramId;
+}
+
+inherits(CatchEntry, Entry);
+exports.CatchEntry = CatchEntry;
+
+function FinallyEntry(firstLoc, afterLoc) {
+  Entry.call(this);
+  n.Literal.assert(firstLoc);
+  n.Literal.assert(afterLoc);
+  this.firstLoc = firstLoc;
+  this.afterLoc = afterLoc;
+}
+
+inherits(FinallyEntry, Entry);
+exports.FinallyEntry = FinallyEntry;
+
+function LabeledEntry(breakLoc, label) {
+  Entry.call(this);
+
+  n.Literal.assert(breakLoc);
+  n.Identifier.assert(label);
+
+  this.breakLoc = breakLoc;
+  this.label = label;
+}
+
+inherits(LabeledEntry, Entry);
+exports.LabeledEntry = LabeledEntry;
+
+function LeapManager(emitter) {
+  assert.ok(this instanceof LeapManager);
+
+  var Emitter = require("./emit").Emitter;
+  assert.ok(emitter instanceof Emitter);
+
+  this.emitter = emitter;
+  this.entryStack = [new FunctionEntry(emitter.finalLoc)];
+}
+
+var LMp = LeapManager.prototype;
+exports.LeapManager = LeapManager;
+
+LMp.withEntry = function(entry, callback) {
+  assert.ok(entry instanceof Entry);
+  this.entryStack.push(entry);
+  try {
+    callback.call(this.emitter);
+  } finally {
+    var popped = this.entryStack.pop();
+    assert.strictEqual(popped, entry);
+  }
+};
+
+LMp._findLeapLocation = function(property, label) {
+  for (var i = this.entryStack.length - 1; i >= 0; --i) {
+    var entry = this.entryStack[i];
+    var loc = entry[property];
+    if (loc) {
+      if (label) {
+        if (entry.label &&
+            entry.label.name === label.name) {
+          return loc;
+        }
+      } else if (entry instanceof LabeledEntry) {
+        // Ignore LabeledEntry entries unless we are actually breaking to
+        // a label.
+      } else {
+        return loc;
+      }
+    }
+  }
+
+  return null;
+};
+
+LMp.getBreakLoc = function(label) {
+  return this._findLeapLocation("breakLoc", label);
+};
+
+LMp.getContinueLoc = function(label) {
+  return this._findLeapLocation("continueLoc", label);
+};

themes/ceras/node_modules/regenerator-6to5/lib/meta.js

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var m = require("private").makeAccessor();
+var types = require("ast-types");
+var isArray = types.builtInTypes.array;
+var n = types.namedTypes;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+function makePredicate(propertyName, knownTypes) {
+  function onlyChildren(node) {
+    n.Node.assert(node);
+
+    // Assume no side effects until we find out otherwise.
+    var result = false;
+
+    function check(child) {
+      if (result) {
+        // Do nothing.
+      } else if (isArray.check(child)) {
+        child.some(check);
+      } else if (n.Node.check(child)) {
+        assert.strictEqual(result, false);
+        result = predicate(child);
+      }
+      return result;
+    }
+
+    types.eachField(node, function(name, child) {
+      check(child);
+    });
+
+    return result;
+  }
+
+  function predicate(node) {
+    n.Node.assert(node);
+
+    var meta = m(node);
+    if (hasOwn.call(meta, propertyName))
+      return meta[propertyName];
+
+    // Certain types are "opaque," which means they have no side
+    // effects or leaps and we don't care about their subexpressions.
+    if (hasOwn.call(opaqueTypes, node.type))
+      return meta[propertyName] = false;
+
+    if (hasOwn.call(knownTypes, node.type))
+      return meta[propertyName] = true;
+
+    return meta[propertyName] = onlyChildren(node);
+  }
+
+  predicate.onlyChildren = onlyChildren;
+
+  return predicate;
+}
+
+var opaqueTypes = {
+  FunctionExpression: true
+};
+
+// These types potentially have side effects regardless of what side
+// effects their subexpressions have.
+var sideEffectTypes = {
+  CallExpression: true, // Anything could happen!
+  ForInStatement: true, // Modifies the key variable.
+  UnaryExpression: true, // Think delete.
+  BinaryExpression: true, // Might invoke .toString() or .valueOf().
+  AssignmentExpression: true, // Side-effecting by definition.
+  UpdateExpression: true, // Updates are essentially assignments.
+  NewExpression: true // Similar to CallExpression.
+};
+
+// These types are the direct cause of all leaps in control flow.
+var leapTypes = {
+  YieldExpression: true,
+  BreakStatement: true,
+  ContinueStatement: true,
+  ReturnStatement: true,
+  ThrowStatement: true
+};
+
+// All leap types are also side effect types.
+for (var type in leapTypes) {
+  if (hasOwn.call(leapTypes, type)) {
+    sideEffectTypes[type] = leapTypes[type];
+  }
+}
+
+exports.hasSideEffects = makePredicate("hasSideEffects", sideEffectTypes);
+exports.containsLeap = makePredicate("containsLeap", leapTypes);

themes/ceras/node_modules/regenerator-6to5/lib/util.js

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var types = require("ast-types");
+var n = types.namedTypes;
+var b = types.builders;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+exports.defaults = function(obj) {
+  var len = arguments.length;
+  var extension;
+
+  for (var i = 1; i < len; ++i) {
+    if ((extension = arguments[i])) {
+      for (var key in extension) {
+        if (hasOwn.call(extension, key) && !hasOwn.call(obj, key)) {
+          obj[key] = extension[key];
+        }
+      }
+    }
+  }
+
+  return obj;
+};
+
+exports.runtimeProperty = function(name) {
+  return b.memberExpression(
+    b.identifier("regeneratorRuntime"),
+    b.identifier(name),
+    false
+  );
+};
+
+// Inspired by the isReference function from ast-util:
+// https://github.com/eventualbuddha/ast-util/blob/9bf91c5ce8/lib/index.js#L466-L506
+exports.isReference = function(path, name) {
+  var node = path.value;
+
+  if (!n.Identifier.check(node)) {
+    return false;
+  }
+
+  if (name && node.name !== name) {
+    return false;
+  }
+
+  var parent = path.parent.value;
+
+  switch (parent.type) {
+  case "VariableDeclarator":
+    return path.name === "init";
+
+  case "MemberExpression":
+    return path.name === "object" || (
+      parent.computed && path.name === "property"
+    );
+
+  case "FunctionExpression":
+  case "FunctionDeclaration":
+  case "ArrowFunctionExpression":
+    if (path.name === "id") {
+      return false;
+    }
+
+    if (parent.params === path.parentPath &&
+        parent.params[path.name] === node) {
+      return false;
+    }
+
+    return true;
+
+  case "ClassDeclaration":
+  case "ClassExpression":
+    return path.name !== "id";
+
+  case "CatchClause":
+    return path.name !== "param";
+
+  case "Property":
+  case "MethodDefinition":
+    return path.name !== "key";
+
+  case "ImportSpecifier":
+  case "ImportDefaultSpecifier":
+  case "ImportNamespaceSpecifier":
+  case "LabeledStatement":
+    return false;
+
+  default:
+    return true;
+  }
+};

themes/ceras/node_modules/regenerator-6to5/lib/visit.js

@@ -0,0 +1,259 @@
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var fs = require("fs");
+var types = require("ast-types");
+var n = types.namedTypes;
+var b = types.builders;
+var isArray = types.builtInTypes.array;
+var isObject = types.builtInTypes.object;
+var NodePath = types.NodePath;
+var hoist = require("./hoist").hoist;
+var Emitter = require("./emit").Emitter;
+var runtimeProperty = require("./util").runtimeProperty;
+
+exports.transform = function transform(node, options) {
+  options = options || {};
+
+  var path = node instanceof NodePath ? node : new NodePath(node);
+  visitor.visit(path, options);
+  node = path.value;
+
+  options.madeChanges = visitor.wasChangeReported();
+
+  return node;
+};
+
+var visitor = types.PathVisitor.fromMethodsObject({
+  reset: function(node, options) {
+    this.options = options;
+  },
+
+  visitFunction: function(path) {
+    // Calling this.traverse(path) first makes for a post-order traversal.
+    this.traverse(path);
+
+    var node = path.value;
+    var shouldTransformAsync = node.async && !this.options.disableAsync;
+
+    if (!node.generator && !shouldTransformAsync) {
+      return;
+    }
+
+    this.reportChanged();
+
+    node.generator = false;
+
+    if (node.expression) {
+      // Transform expression lambdas into normal functions.
+      node.expression = false;
+      node.body = b.blockStatement([
+        b.returnStatement(node.body)
+      ]);
+    }
+
+    if (shouldTransformAsync) {
+      awaitVisitor.visit(path.get("body"));
+    }
+
+    var outerFnId = node.id || (
+      node.id = path.scope.parent.declareTemporary("callee$")
+    );
+
+    var outerBody = [];
+    var bodyBlock = path.value.body;
+    bodyBlock.body = bodyBlock.body.filter(function (node) {
+      if (node && node._blockHoist != null) {
+        outerBody.push(node);
+        return false;
+      } else {
+        return true;
+      }
+    });
+
+    var innerFnId = b.identifier(node.id.name + "$");
+    var contextId = path.scope.declareTemporary("context$");
+    var vars = hoist(path);
+
+    var emitter = new Emitter(contextId);
+    emitter.explode(path.get("body"));
+
+    if (vars && vars.declarations.length > 0) {
+      outerBody.push(vars);
+    }
+
+    var wrapArgs = [
+      emitter.getContextFunction(innerFnId),
+      // Async functions don't care about the outer function because they
+      // don't need it to be marked and don't inherit from its .prototype.
+      shouldTransformAsync ? b.literal(null) : outerFnId,
+      b.thisExpression()
+    ];
+
+    var tryLocsList = emitter.getTryLocsList();
+    if (tryLocsList) {
+      wrapArgs.push(tryLocsList);
+    }
+
+    var wrapCall = b.callExpression(
+      shouldTransformAsync ? runtimeProperty("async") : runtimeProperty("wrap"),
+      wrapArgs
+    );
+
+    outerBody.push(b.returnStatement(wrapCall));
+    node.body = b.blockStatement(outerBody);
+
+    if (shouldTransformAsync) {
+      node.async = false;
+      return;
+    }
+
+    if (n.FunctionDeclaration.check(node)) {
+      var pp = path.parent;
+
+      while (pp && !(n.BlockStatement.check(pp.value) ||
+                     n.Program.check(pp.value))) {
+        pp = pp.parent;
+      }
+
+      if (!pp) {
+        return;
+      }
+
+      // Here we turn the FunctionDeclaration into a named
+      // FunctionExpression that will be assigned to a variable of the
+      // same name at the top of the enclosing block. This is important
+      // for a very subtle reason: named function expressions can refer to
+      // themselves by name without fear that the binding may change due
+      // to code executing outside the function, whereas function
+      // declarations are vulnerable to the following rebinding:
+      //
+      //   function f() { return f }
+      //   var g = f;
+      //   f = "asdf";
+      //   g(); // "asdf"
+      //
+      // One way to prevent the problem illustrated above is to transform
+      // the function declaration thus:
+      //
+      //   var f = function f() { return f };
+      //   var g = f;
+      //   f = "asdf";
+      //   g(); // f
+      //   g()()()()(); // f
+      //
+      // In the code below, we transform generator function declarations
+      // in the following way:
+      //
+      //   gen().next(); // { value: gen, done: true }
+      //   function *gen() {
+      //     return gen;
+      //   }
+      //
+      // becomes something like
+      //
+      //   var gen = runtime.mark(function *gen() {
+      //     return gen;
+      //   });
+      //   gen().next(); // { value: gen, done: true }
+      //
+      // which ensures that the generator body can always reliably refer
+      // to gen by name.
+
+      // Remove the FunctionDeclaration so that we can add it back as a
+      // FunctionExpression passed to runtime.mark.
+      path.replace();
+
+      // Change the type of the function to be an expression instead of a
+      // declaration. Note that all the other fields are the same.
+      node.type = "FunctionExpression";
+
+      var varDecl = b.variableDeclaration("var", [
+        b.variableDeclarator(
+          node.id,
+          b.callExpression(runtimeProperty("mark"), [node])
+        )
+      ]);
+
+      if (node.comments) {
+        // Copy any comments preceding the function declaration to the
+        // variable declaration, to avoid weird formatting consequences.
+        varDecl.leadingComments = node.leadingComments;
+        varDecl.trailingComments = node.trailingComments;
+        node.leadingComments = null;
+        node.trailingComments = null;
+      }
+
+      varDecl._blockHoist = 3;
+
+      var bodyPath = pp.get("body");
+      var bodyLen = bodyPath.value.length;
+
+      bodyPath.push(varDecl);
+
+    } else {
+      n.FunctionExpression.assert(node);
+      return b.callExpression(runtimeProperty("mark"), [node]);
+    }
+  }
+});
+
+function shouldNotHoistAbove(stmtPath) {
+  var value = stmtPath.value;
+  n.Statement.assert(value);
+
+  // If the first statement is a "use strict" declaration, make sure to
+  // insert hoisted declarations afterwards.
+  if (n.ExpressionStatement.check(value) &&
+      n.Literal.check(value.expression) &&
+      value.expression.value === "use strict") {
+    return true;
+  }
+
+  if (n.VariableDeclaration.check(value)) {
+    for (var i = 0; i < value.declarations.length; ++i) {
+      var decl = value.declarations[i];
+      if (n.CallExpression.check(decl.init) &&
+          types.astNodesAreEquivalent(decl.init.callee,
+                                      runtimeProperty("mark"))) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+var awaitVisitor = types.PathVisitor.fromMethodsObject({
+  visitFunction: function(path) {
+    return false; // Don't descend into nested function scopes.
+  },
+
+  visitAwaitExpression: function(path) {
+    // Convert await and await* expressions to yield expressions.
+    var argument = path.value.argument;
+
+    // If the parser supports await* syntax using a boolean .all property
+    // (#171), desugar that syntax to yield Promise.all(argument).
+    if (path.value.all) {
+      argument = b.callExpression(
+        b.memberExpression(
+          b.identifier("Promise"),
+          b.identifier("all"),
+          false
+        ),
+        [argument]
+      );
+    }
+
+    return b.yieldExpression(argument, false);
+  }
+});

themes/ceras/node_modules/regenerator-6to5/main.js

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var assert = require("assert");
+var path = require("path");
+var fs = require("fs");
+var through = require("through");
+var transform = require("./lib/visit").transform;
+var utils = require("./lib/util");
+var types = require("ast-types");
+var genOrAsyncFunExp = /\bfunction\s*\*|\basync\b/;
+var blockBindingExp = /\b(let|const)\s+/;
+
+function exports(file, options) {
+  var data = [];
+  return through(write, end);
+
+  function write(buf) {
+    data.push(buf);
+  }
+
+  function end() {
+    this.queue(compile(data.join(""), options).code);
+    this.queue(null);
+  }
+}
+
+// To get a writable stream for use as a browserify transform, call
+// require("regenerator")().
+module.exports = exports;
+
+// To include the runtime globally in the current node process, call
+// require("regenerator").runtime().
+function runtime() {
+  require("./runtime");
+}
+exports.runtime = runtime;
+runtime.path = path.join(__dirname, "runtime.js");
+
+// To modify an AST directly, call require("regenerator").transform(ast).
+exports.transform = transform;

themes/ceras/node_modules/regenerator-6to5/package.json

@@ -0,0 +1,78 @@
+{
+  "_from": "regenerator-6to5@0.8.10-1",
+  "_id": "regenerator-6to5@0.8.10-1",
+  "_inBundle": false,
+  "_integrity": "sha1-RvdkcGUYFyiXxN6OlhB8j79+tFI=",
+  "_location": "/regenerator-6to5",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "regenerator-6to5@0.8.10-1",
+    "name": "regenerator-6to5",
+    "escapedName": "regenerator-6to5",
+    "rawSpec": "0.8.10-1",
+    "saveSpec": null,
+    "fetchSpec": "0.8.10-1"
+  },
+  "_requiredBy": [
+    "/6to5-core"
+  ],
+  "_resolved": "https://registry.npmjs.org/regenerator-6to5/-/regenerator-6to5-0.8.10-1.tgz",
+  "_shasum": "46f764706518172897c4de8e96107c8fbf7eb452",
+  "_spec": "regenerator-6to5@0.8.10-1",
+  "_where": "/srv/http/mmap_sarrebourg/user/themes/basic/node_modules/6to5-core",
+  "author": {
+    "name": "Ben Newman",
+    "email": "bn@cs.stanford.edu"
+  },
+  "bin": {
+    "regenerator-6to5": "bin/regenerator"
+  },
+  "bugs": {
+    "url": "https://github.com/facebook/regenerator/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "ast-types": "~0.6.1",
+    "commoner": "~0.10.0",
+    "private": "~0.1.5",
+    "through": "~2.3.6"
+  },
+  "deprecated": false,
+  "description": "Source transformer enabling ECMAScript 6 generator functions (yield) in JavaScript-of-today (ES5)",
+  "devDependencies": {
+    "mocha": "~1.21.4",
+    "promise": "~6.0.1",
+    "semver": "~4.0.3"
+  },
+  "engines": {
+    "node": ">= 0.6"
+  },
+  "homepage": "http://github.com/facebook/regenerator",
+  "keywords": [
+    "generator",
+    "yield",
+    "coroutine",
+    "rewriting",
+    "transformation",
+    "syntax",
+    "codegen",
+    "rewriting",
+    "refactoring",
+    "transpiler",
+    "desugaring",
+    "ES6"
+  ],
+  "license": "BSD",
+  "main": "main.js",
+  "name": "regenerator-6to5",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/facebook/regenerator.git"
+  },
+  "scripts": {
+    "test": "node test/run.js"
+  },
+  "version": "0.8.10-1"
+}

themes/ceras/node_modules/regenerator-6to5/runtime-module.js

@@ -0,0 +1,20 @@
+// This method of obtaining a reference to the global object needs to be
+// kept identical to the way it is obtained in runtime.js
+var g =
+  typeof global === "object" ? global :
+  typeof window === "object" ? window : this;
+
+var hasOwn = Object.prototype.hasOwnProperty;
+var hadRuntime = hasOwn.call(g, "regeneratorRuntime");
+var oldRuntime = hadRuntime && g.regeneratorRuntime;
+delete g.regeneratorRuntime; // Force reevalutation of runtime.js.
+
+module.exports = require("./runtime");
+
+if (hadRuntime) {
+  // Restore the original runtime.
+  g.regeneratorRuntime = oldRuntime;
+} else {
+  // Remove the global property added by runtime.js.
+  delete g.regeneratorRuntime;
+}

themes/ceras/node_modules/regenerator-6to5/runtime.js

@@ -0,0 +1,527 @@
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+!(function(global) {
+  "use strict";
+
+  var hasOwn = Object.prototype.hasOwnProperty;
+  var undefined; // More compressible than void 0.
+  var iteratorSymbol =
+    typeof Symbol === "function" && Symbol.iterator || "@@iterator";
+
+  var inModule = typeof module === "object";
+  var runtime = global.regeneratorRuntime;
+  if (runtime) {
+    if (inModule) {
+      // If regeneratorRuntime is defined globally and we're in a module,
+      // make the exports object identical to regeneratorRuntime.
+      module.exports = runtime;
+    }
+    // Don't bother evaluating the rest of this file if the runtime was
+    // already defined globally.
+    return;
+  }
+
+  // Define the runtime globally (as expected by generated code) as either
+  // module.exports (if we're in a module) or a new, empty object.
+  runtime = global.regeneratorRuntime = inModule ? module.exports : {};
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    return new Generator(innerFn, outerFn, self || null, tryLocsList || []);
+  }
+  runtime.wrap = wrap;
+
+  // Try/catch helper to minimize deoptimizations. Returns a completion
+  // record like context.tryEntries[i].completion. This interface could
+  // have been (and was previously) designed to take a closure to be
+  // invoked without arguments, but in all the cases we care about we
+  // already have an existing method we want to call, so there's no need
+  // to create a new function object. We can even get away with assuming
+  // the method takes exactly one argument, since that happens to be true
+  // in every case, so we don't have to touch the arguments object. The
+  // only additional allocation required is the completion record, which
+  // has a stable shape and so hopefully should be cheap to allocate.
+  function tryCatch(fn, obj, arg) {
+    try {
+      return { type: "normal", arg: fn.call(obj, arg) };
+    } catch (err) {
+      return { type: "throw", arg: err };
+    }
+  }
+
+  var GenStateSuspendedStart = "suspendedStart";
+  var GenStateSuspendedYield = "suspendedYield";
+  var GenStateExecuting = "executing";
+  var GenStateCompleted = "completed";
+
+  // Returning this object from the innerFn has the same effect as
+  // breaking out of the dispatch switch statement.
+  var ContinueSentinel = {};
+
+  // Dummy constructor functions that we use as the .constructor and
+  // .constructor.prototype properties for functions that return Generator
+  // objects. For full spec compliance, you may wish to configure your
+  // minifier not to mangle the names of these two functions.
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype;
+  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
+  GeneratorFunctionPrototype.constructor = GeneratorFunction;
+  GeneratorFunction.displayName = "GeneratorFunction";
+
+  runtime.isGeneratorFunction = function(genFun) {
+    var ctor = typeof genFun === "function" && genFun.constructor;
+    return ctor
+      ? ctor === GeneratorFunction ||
+        // For the native GeneratorFunction constructor, the best we can
+        // do is to check its .name property.
+        (ctor.displayName || ctor.name) === "GeneratorFunction"
+      : false;
+  };
+
+  runtime.mark = function(genFun) {
+    genFun.__proto__ = GeneratorFunctionPrototype;
+    genFun.prototype = Object.create(Gp);
+    return genFun;
+  };
+
+  runtime.async = function(innerFn, outerFn, self, tryLocsList) {
+    return new Promise(function(resolve, reject) {
+      var generator = wrap(innerFn, outerFn, self, tryLocsList);
+      var callNext = step.bind(generator.next);
+      var callThrow = step.bind(generator["throw"]);
+
+      function step(arg) {
+        var record = tryCatch(this, null, arg);
+        if (record.type === "throw") {
+          reject(record.arg);
+          return;
+        }
+
+        var info = record.arg;
+        if (info.done) {
+          resolve(info.value);
+        } else {
+          Promise.resolve(info.value).then(callNext, callThrow);
+        }
+      }
+
+      callNext();
+    });
+  };
+
+  function Generator(innerFn, outerFn, self, tryLocsList) {
+    var generator = outerFn ? Object.create(outerFn.prototype) : this;
+    var context = new Context(tryLocsList);
+    var state = GenStateSuspendedStart;
+
+    function invoke(method, arg) {
+      if (state === GenStateExecuting) {
+        throw new Error("Generator is already running");
+      }
+
+      if (state === GenStateCompleted) {
+        // Be forgiving, per 25.3.3.3.3 of the spec:
+        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+        return doneResult();
+      }
+
+      while (true) {
+        var delegate = context.delegate;
+        if (delegate) {
+          var record = tryCatch(
+            delegate.iterator[method],
+            delegate.iterator,
+            arg
+          );
+
+          if (record.type === "throw") {
+            context.delegate = null;
+
+            // Like returning generator.throw(uncaught), but without the
+            // overhead of an extra function call.
+            method = "throw";
+            arg = record.arg;
+
+            continue;
+          }
+
+          // Delegate generator ran and handled its own exceptions so
+          // regardless of what the method was, we continue as if it is
+          // "next" with an undefined arg.
+          method = "next";
+          arg = undefined;
+
+          var info = record.arg;
+          if (info.done) {
+            context[delegate.resultName] = info.value;
+            context.next = delegate.nextLoc;
+          } else {
+            state = GenStateSuspendedYield;
+            return info;
+          }
+
+          context.delegate = null;
+        }
+
+        if (method === "next") {
+          if (state === GenStateSuspendedStart &&
+              typeof arg !== "undefined") {
+            // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+            throw new TypeError(
+              "attempt to send " + JSON.stringify(arg) + " to newborn generator"
+            );
+          }
+
+          if (state === GenStateSuspendedYield) {
+            context.sent = arg;
+          } else {
+            delete context.sent;
+          }
+
+        } else if (method === "throw") {
+          if (state === GenStateSuspendedStart) {
+            state = GenStateCompleted;
+            throw arg;
+          }
+
+          if (context.dispatchException(arg)) {
+            // If the dispatched exception was caught by a catch block,
+            // then let that catch block handle the exception normally.
+            method = "next";
+            arg = undefined;
+          }
+
+        } else if (method === "return") {
+          context.abrupt("return", arg);
+        }
+
+        state = GenStateExecuting;
+
+        var record = tryCatch(innerFn, self, context);
+        if (record.type === "normal") {
+          // If an exception is thrown from innerFn, we leave state ===
+          // GenStateExecuting and loop back for another invocation.
+          state = context.done
+            ? GenStateCompleted
+            : GenStateSuspendedYield;
+
+          var info = {
+            value: record.arg,
+            done: context.done
+          };
+
+          if (record.arg === ContinueSentinel) {
+            if (context.delegate && method === "next") {
+              // Deliberately forget the last sent value so that we don't
+              // accidentally pass it on to the delegate.
+              arg = undefined;
+            }
+          } else {
+            return info;
+          }
+
+        } else if (record.type === "throw") {
+          state = GenStateCompleted;
+
+          if (method === "next") {
+            context.dispatchException(record.arg);
+          } else {
+            arg = record.arg;
+          }
+        }
+      }
+    }
+
+    generator.next = invoke.bind(generator, "next");
+    generator["throw"] = invoke.bind(generator, "throw");
+    generator["return"] = invoke.bind(generator, "return");
+
+    return generator;
+  }
+
+  Gp[iteratorSymbol] = function() {
+    return this;
+  };
+
+  Gp.toString = function() {
+    return "[object Generator]";
+  };
+
+  function pushTryEntry(locs) {
+    var entry = { tryLoc: locs[0] };
+
+    if (1 in locs) {
+      entry.catchLoc = locs[1];
+    }
+
+    if (2 in locs) {
+      entry.finallyLoc = locs[2];
+      entry.afterLoc = locs[3];
+    }
+
+    this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal";
+    delete record.arg;
+    entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    // The root entry object (effectively a try statement without a catch
+    // or a finally block) gives us a place to store values thrown from
+    // locations where there is no enclosing try statement.
+    this.tryEntries = [{ tryLoc: "root" }];
+    tryLocsList.forEach(pushTryEntry, this);
+    this.reset();
+  }
+
+  runtime.keys = function(object) {
+    var keys = [];
+    for (var key in object) {
+      keys.push(key);
+    }
+    keys.reverse();
+
+    // Rather than returning an object with a next method, we keep
+    // things simple and return the next function itself.
+    return function next() {
+      while (keys.length) {
+        var key = keys.pop();
+        if (key in object) {
+          next.value = key;
+          next.done = false;
+          return next;
+        }
+      }
+
+      // To avoid creating an additional object, we just hang the .value
+      // and .done properties off the next function object itself. This
+      // also ensures that the minifier will not anonymize the function.
+      next.done = true;
+      return next;
+    };
+  };
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) {
+        return iteratorMethod.call(iterable);
+      }
+
+      if (typeof iterable.next === "function") {
+        return iterable;
+      }
+
+      if (!isNaN(iterable.length)) {
+        var i = -1, next = function next() {
+          while (++i < iterable.length) {
+            if (hasOwn.call(iterable, i)) {
+              next.value = iterable[i];
+              next.done = false;
+              return next;
+            }
+          }
+
+          next.value = undefined;
+          next.done = true;
+
+          return next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    // Return an iterator with no values.
+    return { next: doneResult };
+  }
+  runtime.values = values;
+
+  function doneResult() {
+    return { value: undefined, done: true };
+  }
+
+  Context.prototype = {
+    constructor: Context,
+
+    reset: function() {
+      this.prev = 0;
+      this.next = 0;
+      this.sent = undefined;
+      this.done = false;
+      this.delegate = null;
+
+      this.tryEntries.forEach(resetTryEntry);
+
+      // Pre-initialize at least 20 temporary variables to enable hidden
+      // class optimizations for simple generators.
+      for (var tempIndex = 0, tempName;
+           hasOwn.call(this, tempName = "t" + tempIndex) || tempIndex < 20;
+           ++tempIndex) {
+        this[tempName] = null;
+      }
+    },
+
+    stop: function() {
+      this.done = true;
+
+      var rootEntry = this.tryEntries[0];
+      var rootRecord = rootEntry.completion;
+      if (rootRecord.type === "throw") {
+        throw rootRecord.arg;
+      }
+
+      return this.rval;
+    },
+
+    dispatchException: function(exception) {
+      if (this.done) {
+        throw exception;
+      }
+
+      var context = this;
+      function handle(loc, caught) {
+        record.type = "throw";
+        record.arg = exception;
+        context.next = loc;
+        return !!caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        var record = entry.completion;
+
+        if (entry.tryLoc === "root") {
+          // Exception thrown outside of any try block that could handle
+          // it, so set the completion value of the entire function to
+          // throw the exception.
+          return handle("end");
+        }
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc");
+          var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            } else if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            }
+
+          } else if (hasFinally) {
+            if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+
+          } else {
+            throw new Error("try statement without catch or finally");
+          }
+        }
+      }
+    },
+
+    _findFinallyEntry: function(finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc <= this.prev &&
+            hasOwn.call(entry, "finallyLoc") && (
+              entry.finallyLoc === finallyLoc ||
+              this.prev < entry.finallyLoc)) {
+          return entry;
+        }
+      }
+    },
+
+    abrupt: function(type, arg) {
+      var entry = this._findFinallyEntry();
+      var record = entry ? entry.completion : {};
+
+      record.type = type;
+      record.arg = arg;
+
+      if (entry) {
+        this.next = entry.finallyLoc;
+      } else {
+        this.complete(record);
+      }
+
+      return ContinueSentinel;
+    },
+
+    complete: function(record, afterLoc) {
+      if (record.type === "throw") {
+        throw record.arg;
+      }
+
+      if (record.type === "break" ||
+          record.type === "continue") {
+        this.next = record.arg;
+      } else if (record.type === "return") {
+        this.rval = record.arg;
+        this.next = "end";
+      } else if (record.type === "normal" && afterLoc) {
+        this.next = afterLoc;
+      }
+
+      return ContinueSentinel;
+    },
+
+    finish: function(finallyLoc) {
+      var entry = this._findFinallyEntry(finallyLoc);
+      return this.complete(entry.completion, entry.afterLoc);
+    },
+
+    "catch": function(tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+          if (record.type === "throw") {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+          return thrown;
+        }
+      }
+
+      // The context.catch method must only be called with a location
+      // argument that corresponds to a known catch block.
+      throw new Error("illegal catch attempt");
+    },
+
+    delegateYield: function(iterable, resultName, nextLoc) {
+      this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      };
+
+      return ContinueSentinel;
+    }
+  };
+})(
+  // Among the various tricks for obtaining a reference to the global
+  // object, this seems to be the most reliable technique that does not
+  // use indirect eval (which violates Content Security Policy).
+  typeof global === "object" ? global :
+  typeof window === "object" ? window : this
+);