push all website files

website/functions/node_modules/power-assert-context-traversal/lib/context-traversal.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var EventEmitter = require('events').EventEmitter;
+var inherits = require('util').inherits;
+var estraverse = require('estraverse');
+var forEach = require('core-js/library/fn/array/for-each');
+var reduce = require('core-js/library/fn/array/reduce');
+var locationOf = require('./location');
+var literalPattern = /^(?:String|Numeric|Null|Boolean|RegExp)?Literal$/;
+var assign = require('core-js/library/fn/object/assign');
+
+function ContextTraversal (powerAssertContext) {
+    this.powerAssertContext = powerAssertContext;
+    EventEmitter.call(this);
+}
+inherits(ContextTraversal, EventEmitter);
+
+ContextTraversal.prototype.traverse = function () {
+    var _this = this;
+    var source = _this.powerAssertContext.source;
+    parseIfJson(source, 'ast');
+    parseIfJson(source, 'tokens');
+    parseIfJson(source, 'visitorKeys');
+    _this.emit('start', this.powerAssertContext);
+    forEach(this.powerAssertContext.args, function (capturedArgument) {
+        onEachEsNode(capturedArgument, source, function (esNode) {
+            _this.emit('data', esNode);
+        });
+    });
+    _this.emit('end');
+};
+
+function parseIfJson (source, propName) {
+    if (typeof source[propName] === 'string') {
+        source[propName] = JSON.parse(source[propName]);
+    }
+}
+
+function onEachEsNode(capturedArgument, source, callback) {
+    var espathToValue = reduce(capturedArgument.events, function (accum, ev) {
+        accum[ev.espath] = ev.value;
+        return accum;
+    }, {});
+    var nodeStack = [];
+    estraverse.traverse(source.ast, {
+        keys: source.visitorKeys,
+        enter: function (currentNode, parentNode) {
+            var parentEsNode = (0 < nodeStack.length) ? nodeStack[nodeStack.length - 1] : null;
+            var esNode = createEsNode(this.path(), currentNode, espathToValue, source.content, source.tokens, parentEsNode);
+            nodeStack.push(esNode);
+            callback(esNode);
+        },
+        leave: function (currentNode, parentNode) {
+            nodeStack.pop();
+        }
+    });
+}
+
+function isLiteral (node) {
+    return literalPattern.test(node.type);
+}
+
+function createEsNode (path, currentNode, espathToValue, jsCode, tokens, parent) {
+    var espath = path ? path.join('/') : '';
+    return {
+        espath: espath,
+        parent: parent,
+        key: path ? path[path.length - 1] : null,
+        node: currentNode,
+        code: jsCode.slice(currentNode.range[0], currentNode.range[1]),
+        value: isLiteral(currentNode) ? currentNode.value : espathToValue[espath],
+        isCaptured: espathToValue.hasOwnProperty(espath),
+        range: locationOf(currentNode, tokens)
+    };
+}
+
+module.exports = ContextTraversal;

website/functions/node_modules/power-assert-context-traversal/lib/location.js

@@ -0,0 +1,80 @@
+'use strict';
+
+var syntax = require('estraverse').Syntax;
+
+function locationOf(currentNode, tokens) {
+    switch(currentNode.type) {
+    case syntax.MemberExpression:
+        return propertyLocationOf(currentNode, tokens);
+    case syntax.CallExpression:
+        if (currentNode.callee.type === syntax.MemberExpression) {
+            return propertyLocationOf(currentNode.callee, tokens);
+        }
+        break;
+    case syntax.BinaryExpression:
+    case syntax.LogicalExpression:
+    case syntax.AssignmentExpression:
+        return infixOperatorLocationOf(currentNode, tokens);
+    default:
+        break;
+    }
+    return currentNode.range;
+}
+
+function propertyLocationOf(memberExpression, tokens) {
+    var prop = memberExpression.property;
+    var token;
+    if (!memberExpression.computed) {
+        return prop.range;
+    }
+    token = findLeftBracketTokenOf(memberExpression, tokens);
+    return token ? token.range : prop.range;
+}
+
+// calculate location of infix operator for BinaryExpression, AssignmentExpression and LogicalExpression.
+function infixOperatorLocationOf (expression, tokens) {
+    var token = findOperatorTokenOf(expression, tokens);
+    return token ? token.range : expression.left.range;
+}
+
+function findLeftBracketTokenOf(expression, tokens) {
+    var fromColumn = expression.property.range[0];
+    return searchToken(tokens, function (token, index) {
+        var prevToken;
+        if (token.range[0] === fromColumn) {
+            prevToken = tokens[index - 1];
+            // if (prevToken.type === 'Punctuator' && prevToken.value === '[') {  // esprima
+            if (prevToken.type.label === '[') {  // acorn
+                return prevToken;
+            }
+        }
+        return undefined;
+    });
+}
+
+function findOperatorTokenOf(expression, tokens) {
+    var fromColumn = expression.left.range[1];
+    var toColumn = expression.right.range[0];
+    return searchToken(tokens, function (token, index) {
+        if (fromColumn < token.range[0] &&
+            token.range[1] < toColumn &&
+            token.value === expression.operator) {
+            return token;
+        }
+        return undefined;
+    });
+}
+
+function searchToken(tokens, predicate) {
+    var i, token, found;
+    for(i = 0; i < tokens.length; i += 1) {
+        token = tokens[i];
+        found = predicate(token, i);
+        if (found) {
+            return found;
+        }
+    }
+    return undefined;
+}
+
+module.exports = locationOf;