push all website files

website/functions/node_modules/power-assert-context-traversal/README.md

@@ -0,0 +1,132 @@
+[![power-assert][power-assert-banner]][power-assert-url]
+
+[![Build Status][travis-image]][travis-url]
+[![NPM version][npm-image]][npm-url]
+[![License][license-image]][license-url]
+
+
+EventEmitter of `powerAssertContext` object provided by power-assert at runtime.
+
+
+API
+---------------------------------------
+
+### var traversal = new ContextTraversal(powerAssertContext);
+
+Create `EventEmitter` of `powerAssertContext` object, having structure below.
+
+```javascript
+{
+    source: {
+        content: 'assert(foo === bar)',
+        filepath: 'test/some_test.js',
+        line: 1,
+        ast: '### JSON representation of AST nodes ###',
+        tokens: '### JSON representation of AST tokens ###',
+        visitorKeys: '### JSON representation of AST visitor keys ###'
+    },
+    args: [
+        {
+            value: false,
+            events: [
+                {
+                    value: "FOO",
+                    espath: "arguments/0/left"
+                },
+                {
+                    value: "BAR",
+                    espath: "arguments/0/right"
+                },
+                {
+                    value: false,
+                    espath: "arguments/0"
+                }
+            ]
+        }
+    ]
+}
+```
+
+### traversal.traverse()
+
+Fire events while traversing AST tree in `powerAssertContext`.
+
+
+### events
+
+
+#### traversal.on('start', function (powerAssertContext) {})
+
+Called once when traversal starts. Argument is the `powerAssertContext` object under traversal.
+
+#### traversal.on('data', function (esNode) {})
+
+Called for each Node of AST in `powerAssertContext`. Argument is a `EsNode` object, having structure below.
+
+```javascript
+{
+    espath: 'arguments/0',
+    parent: '### parent esNode reference unless root ###',
+    key: 0,
+    node: {
+        type: 'BinaryExpression',
+        operator: '===',
+        left: { type: 'Identifier', name: 'foo', range: [ 7, 10 ] },
+        right: { type: 'Identifier', name: 'bar', range: [ 15, 18 ] },
+        range: [ 7, 18 ]
+    },
+    code: 'foo === bar',
+    value: false,
+    isCaptured: true,
+    range: [ 11, 14 ]  // range of operator
+};
+```
+
+```javascript
+{
+    espath: 'arguments/0/right',
+    parent: '### parent esNode reference unless root ###',
+    key: 'right',
+    node: { type: 'Identifier', name: 'bar', range: [ 15, 18 ] },
+    code: 'bar',
+    value: 'BAR',
+    isCaptured: true,
+    range: [ 15, 18 ]
+};
+```
+
+#### traversal.on('end', function () {})
+
+Called once when traversal ends.
+
+
+
+INSTALL
+---------------------------------------
+
+```sh
+$ npm install --save-dev power-assert-context-traversal
+```
+
+
+AUTHOR
+---------------------------------------
+* [Takuto Wada](https://github.com/twada)
+
+
+LICENSE
+---------------------------------------
+Licensed under the [MIT](https://github.com/twada/power-assert-runtime/blob/master/LICENSE) license.
+
+
+[power-assert-url]: https://github.com/power-assert-js/power-assert
+[power-assert-banner]: https://raw.githubusercontent.com/power-assert-js/power-assert-js-logo/master/banner/banner-official-fullcolor.png
+
+[travis-url]: https://travis-ci.org/twada/power-assert-runtime
+[travis-image]: https://secure.travis-ci.org/twada/power-assert-runtime.svg?branch=master
+
+[npm-url]: https://npmjs.org/package/power-assert-context-traversal
+[npm-image]: https://badge.fury.io/js/power-assert-context-traversal.svg
+
+[license-url]: https://github.com/twada/power-assert-runtime/blob/master/LICENSE
+[license-image]: https://img.shields.io/badge/license-MIT-brightgreen.svg

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

@@ -0,0 +1 @@
+module.exports = require('./lib/context-traversal');

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;

website/functions/node_modules/power-assert-context-traversal/package.json

@@ -0,0 +1,64 @@
+{
+  "_from": "power-assert-context-traversal@^1.2.0",
+  "_id": "power-assert-context-traversal@1.2.0",
+  "_inBundle": false,
+  "_integrity": "sha512-NFoHU6g2umNajiP2l4qb0BRWD773Aw9uWdWYH9EQsVwIZnog5bd2YYLFCVvaxWpwNzWeEfZIon2xtyc63026pQ==",
+  "_location": "/power-assert-context-traversal",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "power-assert-context-traversal@^1.2.0",
+    "name": "power-assert-context-traversal",
+    "escapedName": "power-assert-context-traversal",
+    "rawSpec": "^1.2.0",
+    "saveSpec": null,
+    "fetchSpec": "^1.2.0"
+  },
+  "_requiredBy": [
+    "/power-assert-context-formatter"
+  ],
+  "_resolved": "https://registry.npmjs.org/power-assert-context-traversal/-/power-assert-context-traversal-1.2.0.tgz",
+  "_shasum": "f6e71454baf640de5c1c9c270349f5c9ab0b2e94",
+  "_spec": "power-assert-context-traversal@^1.2.0",
+  "_where": "C:\\Users\\jlevi\\Downloads\\tr2022-strategy-master\\tr2022-strategy-master\\data analysis\\functions\\node_modules\\power-assert-context-formatter",
+  "author": {
+    "name": "Takuto Wada",
+    "email": "takuto.wada@gmail.com",
+    "url": "https://github.com/twada"
+  },
+  "bugs": {
+    "url": "https://github.com/twada/power-assert-runtime/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "core-js": "^2.0.0",
+    "estraverse": "^4.1.0"
+  },
+  "deprecated": false,
+  "description": "traverse power-assert context",
+  "devDependencies": {
+    "babel-types": "^6.1.0",
+    "mocha": "^5.0.0"
+  },
+  "files": [
+    "README.md",
+    "index.js",
+    "lib"
+  ],
+  "homepage": "https://github.com/twada/power-assert-runtime",
+  "keywords": [
+    "power-assert"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "power-assert-context-traversal",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/twada/power-assert-runtime.git"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "version": "1.2.0"
+}