Current Dev State

static/js/ketcher2/node_modules/detective/LICENSE

@@ -0,0 +1,18 @@
+This software is released under the MIT license:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

static/js/ketcher2/node_modules/detective/bench/ddetect.js

@@ -0,0 +1,7 @@
+var detective = require('../faster.js');
+var fs = require('fs');
+
+var src = fs.readFileSync(process.argv[2], 'utf8');
+var t0 = Date.now();
+var requires = detective(src);
+console.log(Date.now() - t0);

static/js/ketcher2/node_modules/detective/bench/detect.js

@@ -0,0 +1,7 @@
+var detective = require('../');
+var fs = require('fs');
+
+var src = fs.readFileSync(__dirname + '/src/jquery.js', 'utf8');
+var t0 = Date.now();
+var requires = detective(src);
+console.log(Date.now() - t0);

static/js/ketcher2/node_modules/detective/bench/esprima_v_acorn.txt

@@ -0,0 +1,18 @@
+esprima:
+
+  $ for i in {1..5}; do node detect.js; done
+  704
+  702
+  704
+  704
+  697
+
+acorn:
+
+  $ for i in {1..5}; do node detect.js; done
+  555
+  552
+  585
+  549
+  583
+

static/js/ketcher2/node_modules/detective/example/strings.js

@@ -0,0 +1,6 @@
+var detective = require('../');
+var fs = require('fs');
+
+var src = fs.readFileSync(__dirname + '/strings_src.js');
+var requires = detective(src);
+console.dir(requires);

static/js/ketcher2/node_modules/detective/example/strings_src.js

@@ -0,0 +1,3 @@
+var a = require('a');
+var b = require('b');
+var c = require('c');

static/js/ketcher2/node_modules/detective/index.js

@@ -0,0 +1,71 @@
+var acorn = require('acorn');
+var walk = require('acorn/dist/walk');
+var defined = require('defined');
+
+var requireRe = /\brequire\b/;
+
+function parse (src, opts) {
+    if (!opts) opts = {};
+    return acorn.parse(src, {
+        ecmaVersion: defined(opts.ecmaVersion, 8),
+        sourceType: opts.sourceType,
+        ranges: defined(opts.ranges, opts.range),
+        locations: defined(opts.locations, opts.loc),
+        allowReserved: defined(opts.allowReserved, true),
+        allowReturnOutsideFunction: defined(
+            opts.allowReturnOutsideFunction, true
+        ),
+        allowHashBang: defined(opts.allowHashBang, true)
+    });
+}
+
+var exports = module.exports = function (src, opts) {
+    return exports.find(src, opts).strings;
+};
+
+exports.find = function (src, opts) {
+    if (!opts) opts = {};
+    
+    var word = opts.word === undefined ? 'require' : opts.word;
+    if (typeof src !== 'string') src = String(src);
+    
+    var isRequire = opts.isRequire || function (node) {
+        return node.callee.type === 'Identifier'
+            && node.callee.name === word
+        ;
+    };
+    
+    var modules = { strings : [], expressions : [] };
+    if (opts.nodes) modules.nodes = [];
+    
+    var wordRe = word === 'require' ? requireRe : RegExp('\\b' + word + '\\b');
+    if (!wordRe.test(src)) return modules;
+    
+    var ast = parse(src, opts.parse);
+    
+    function visit(node, st, c) {
+        var hasRequire = wordRe.test(src.slice(node.start, node.end));
+        if (!hasRequire) return;
+        walk.base[node.type](node, st, c);
+        if (node.type !== 'CallExpression') return;
+        if (isRequire(node)) {
+            if (node.arguments.length) {
+                var arg = node.arguments[0];
+                if (arg.type === 'Literal') {
+                    modules.strings.push(arg.value);
+                }
+                else {
+                    modules.expressions.push(src.slice(arg.start, arg.end));
+                }
+            }
+            if (opts.nodes) modules.nodes.push(node);
+        }
+    }
+    
+    walk.recursive(ast, null, {
+        Statement: visit,
+        Expression: visit
+    });
+    
+    return modules;
+};

static/js/ketcher2/node_modules/detective/package.json

@@ -0,0 +1,62 @@
+{
+  "_from": "detective@^4.0.0",
+  "_id": "detective@4.5.0",
+  "_inBundle": false,
+  "_integrity": "sha1-blqMaybmx6JUsca210kNmOyR7dE=",
+  "_location": "/detective",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "detective@^4.0.0",
+    "name": "detective",
+    "escapedName": "detective",
+    "rawSpec": "^4.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^4.0.0"
+  },
+  "_requiredBy": [
+    "/module-deps",
+    "/replace-requires"
+  ],
+  "_resolved": "https://registry.npmjs.org/detective/-/detective-4.5.0.tgz",
+  "_shasum": "6e5a8c6b26e6c7a254b1c6b6d7490d98ec91edd1",
+  "_spec": "detective@^4.0.0",
+  "_where": "/home/manfred/enviPath/ketcher2/ketcher/node_modules/module-deps",
+  "author": {
+    "name": "James Halliday",
+    "email": "mail@substack.net",
+    "url": "http://substack.net"
+  },
+  "bugs": {
+    "url": "https://github.com/substack/node-detective/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "acorn": "^4.0.3",
+    "defined": "^1.0.0"
+  },
+  "deprecated": false,
+  "description": "find all require() calls by walking the AST",
+  "devDependencies": {
+    "tap": "^5.7.1"
+  },
+  "homepage": "https://github.com/substack/node-detective#readme",
+  "keywords": [
+    "require",
+    "source",
+    "analyze",
+    "ast"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "detective",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/substack/node-detective.git"
+  },
+  "scripts": {
+    "test": "tap test/*.js"
+  },
+  "version": "4.5.0"
+}

static/js/ketcher2/node_modules/detective/readme.markdown

@@ -0,0 +1,81 @@
+# detective
+
+find all calls to `require()` by walking the AST
+
+[![build status](https://secure.travis-ci.org/substack/node-detective.png)](http://travis-ci.org/substack/node-detective)
+
+# example
+
+## strings
+
+strings_src.js:
+
+``` js
+var a = require('a');
+var b = require('b');
+var c = require('c');
+```
+
+strings.js:
+
+``` js
+var detective = require('detective');
+var fs = require('fs');
+
+var src = fs.readFileSync(__dirname + '/strings_src.js');
+var requires = detective(src);
+console.dir(requires);
+```
+
+output:
+
+```
+$ node examples/strings.js
+[ 'a', 'b', 'c' ]
+```
+
+# methods
+
+``` js
+var detective = require('detective');
+```
+
+## detective(src, opts)
+
+Give some source body `src`, return an array of all the `require()` calls with
+string arguments.
+
+The options parameter `opts` is passed along to `detective.find()`.
+
+## var found = detective.find(src, opts)
+
+Give some source body `src`, return `found` with:
+
+* `found.strings` - an array of each string found in a `require()`
+* `found.expressions` - an array of each stringified expression found in a
+`require()` call
+* `found.nodes` (when `opts.nodes === true`) - an array of AST nodes for each
+argument found in a `require()` call
+
+Optionally:
+
+* `opts.word` - specify a different function name instead of `"require"`
+* `opts.nodes` - when `true`, populate `found.nodes`
+* `opts.isRequire(node)` - a function returning whether an AST `CallExpression`
+node is a require call
+* `opts.parse` - supply options directly to
+[acorn](https://npmjs.org/package/acorn) with some support for esprima-style
+options `range` and `loc`
+* `opts.ecmaVersion` - default: 8
+
+# install
+
+With [npm](https://npmjs.org) do:
+
+```
+npm install detective
+```
+
+# license
+
+MIT

static/js/ketcher2/node_modules/detective/test/both.js

@@ -0,0 +1,26 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/both.js');
+
+test('both', function (t) {
+    var modules = detective.find(src);
+    t.deepEqual(modules.strings, [ 'a', 'b' ]);
+    t.deepEqual(modules.expressions, [ "'c' + x", "'d' + y" ]);
+    t.notOk(modules.nodes, 'has no nodes');
+    t.end();
+});
+
+test('both with nodes specified in opts', function (t) {
+    var modules = detective.find(src, { nodes: true });
+    t.deepEqual(modules.strings, [ 'a', 'b' ]);
+    t.deepEqual(modules.expressions, [ "'c' + x", "'d' + y" ]);
+    t.deepEqual(
+      modules.nodes.map(function (n) { 
+        var arg = n.arguments[0];
+        return arg.value || arg.left.value; 
+      }),
+      [ 'a', 'b', 'c', 'd' ],
+      'has a node for each require');
+    t.end();
+});

static/js/ketcher2/node_modules/detective/test/chained.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/chained.js');
+
+test('chained', function (t) {
+    t.deepEqual(detective(src), [ 'c', 'b', 'a' ]);
+    t.end();
+});

static/js/ketcher2/node_modules/detective/test/complicated.js

@@ -0,0 +1,56 @@
+var test = require('tap').test;
+var detective = require('../');
+
+var sources = [
+    'require("a")',
+    ';require("a")',
+    ' require("a")',
+    'void require("a")',
+    '+require("a")',
+    '!require("a")',
+    '/*comments*/require("a")',
+    '(require("a"))',
+
+    'require/*comments*/("a")',
+    ';require/*comments*/("a")',
+    ' require/*comments*/("a")',
+    'void require/*comments*/("a")',
+    '+require/*comments*/("a")',
+    '!require/*comments*/("a")',
+    '/*comments*/require/*comments*/("a")',
+    '(require/*comments*/("a"))',
+
+    'require /*comments*/ ("a")',
+    ';require /*comments*/ ("a")',
+    ' require /*comments*/ ("a")',
+    'void require /*comments*/ ("a")',
+    '+require /*comments*/ ("a")',
+    '!require /*comments*/ ("a")',
+    ' /*comments*/ require /*comments*/ ("a")',
+    '(require /*comments*/ ("a"))',
+
+    'require /*comments*/ /*more comments*/ ("a")',
+    ';require /*comments*/ /*more comments*/ ("a")',
+    ' require /*comments*/ /*more comments*/ ("a")',
+    'void require /*comments*/ /*more comments*/ ("a")',
+    '+require /*comments*/ /*more comments*/ ("a")',
+    '!require /*comments*/ /*more comments*/ ("a")',
+    ' /*comments*/ /*more comments*/ require /*comments*/ /*more comments*/ ("a")',
+    '(require /*comments*/ /*more comments*/ ("a"))',
+
+    'require//comments\n("a")',
+    ';require//comments\n("a")',
+    ' require//comments\n("a")',
+    'void require//comments\n("a")',
+    '+require//comments\n("a")',
+    '!require//comments\n("a")',
+    '  require//comments\n("a")',
+    '(require//comments\n("a"))'
+];
+
+test('complicated', function (t) {
+    t.plan(sources.length);
+    sources.forEach(function(src) {
+        t.deepEqual(detective(src), [ 'a' ]);
+    });
+});

static/js/ketcher2/node_modules/detective/test/es6-module.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/es6-module.js');
+
+test('es6-module', function (t) {
+    t.plan(1);
+    t.deepEqual(detective(src, {parse: {sourceType: 'module'}}), [ 'a', 'b' ]);
+});

static/js/ketcher2/node_modules/detective/test/files/both.js

@@ -0,0 +1,4 @@
+require('a');
+require('b');
+require('c' + x);
+var moo = require('d' + y).moo;

static/js/ketcher2/node_modules/detective/test/files/chained.js

@@ -0,0 +1,5 @@
+
+
+require('c').hello().goodbye()
+require('b').hello()
+require('a')

static/js/ketcher2/node_modules/detective/test/files/es6-module.js

@@ -0,0 +1,5 @@
+var a = require('a');
+
+export default function () {
+    var b = require('b');
+}

static/js/ketcher2/node_modules/detective/test/files/generators.js

@@ -0,0 +1,5 @@
+var a = require('a');
+
+function *gen() {
+  yield require('b');
+}

static/js/ketcher2/node_modules/detective/test/files/isrequire.js

@@ -0,0 +1,14 @@
+var a = require.async('a');
+var b = require.async('b');
+var c = require.async('c');
+var abc = a.b(c);
+
+var EventEmitter = require.async('events').EventEmitter;
+
+var x = require.async('doom')(5,6,7);
+x(8,9);
+c.load('notthis');
+var y = require.async('y') * 100;
+
+var EventEmitter2 = require.async('events2').EventEmitter();
+

static/js/ketcher2/node_modules/detective/test/files/nested.js

@@ -0,0 +1,22 @@
+
+if (true) {
+    (function () {
+        require('a');
+    })();
+}
+if (false) {
+    (function () {
+        var x = 10;
+        switch (x) {
+            case 1 : require('b'); break;
+            default : break;
+        }
+    })()
+}
+
+function qqq () {
+    require
+        (
+        "c"
+    );
+}

static/js/ketcher2/node_modules/detective/test/files/shebang.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+var a = require('a');
+var b = require('b');
+var c = require('c');

static/js/ketcher2/node_modules/detective/test/files/sparse-array.js

@@ -0,0 +1,3 @@
+var o = [,,,,]
+
+require('./foo')

static/js/ketcher2/node_modules/detective/test/files/strings.js

@@ -0,0 +1,13 @@
+var a = require('a');
+var b = require('b');
+var c = require('c');
+var abc = a.b(c);
+
+var EventEmitter = require('events').EventEmitter;
+
+var x = require('doom')(5,6,7);
+x(8,9);
+c.require('notthis');
+var y = require('y') * 100;
+
+var EventEmitter2 = require('events2').EventEmitter();

static/js/ketcher2/node_modules/detective/test/files/word.js

@@ -0,0 +1,13 @@
+var a = load('a');
+var b = load('b');
+var c = load('c');
+var abc = a.b(c);
+
+var EventEmitter = load('events').EventEmitter;
+
+var x = load('doom')(5,6,7);
+x(8,9);
+c.load('notthis');
+var y = load('y') * 100;
+
+var EventEmitter2 = load('events2').EventEmitter();

static/js/ketcher2/node_modules/detective/test/files/yield.js

@@ -0,0 +1,4 @@
+(function * () {
+    var a = require('a');
+    var b = yield require('c')(a);
+})();

static/js/ketcher2/node_modules/detective/test/generators.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/generators.js');
+
+test('generators', function (t) {
+    t.plan(1);
+    t.deepEqual(detective(src), [ 'a', 'b' ]);
+});

static/js/ketcher2/node_modules/detective/test/isrequire.js

@@ -0,0 +1,20 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/isrequire.js');
+
+test('word', function (t) {
+    t.deepEqual(
+        detective(src, { isRequire: function(node) {
+          return (node.type === 'CallExpression' &&
+              node.callee.type === 'MemberExpression' &&
+              node.callee.object.type == 'Identifier' &&
+              node.callee.object.name == 'require' &&
+              node.callee.property.type == 'Identifier' &&
+              node.callee.property.name == 'async')
+        } }),
+        [ 'a', 'b', 'c', 'events', 'doom', 'y', 'events2' ]
+    );
+    t.end();
+});
+

static/js/ketcher2/node_modules/detective/test/nested.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/nested.js');
+
+test('nested', function (t) {
+    t.deepEqual(detective(src), [ 'a', 'b', 'c' ]);
+    t.end();
+});

static/js/ketcher2/node_modules/detective/test/noargs.js

@@ -0,0 +1,26 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+
+// in order to use detective to find any function
+// it needs to properly handle functions called without args
+var src = [ 'fn();', 'otherfn();', 'fn();' ].join('\n')
+
+test('noargs', function (t) {
+    t.plan(1);
+    t.deepEqual(detective(src, { word: 'fn' }).length, 0, 'finds no arg id');
+});
+
+test('find noargs with nodes', function (t) {
+    t.plan(4);
+    var modules = detective.find(src, { word: 'fn', nodes: true });
+    t.equal(modules.strings.length, 0, 'finds no arg id');
+    t.equal(modules.expressions.length, 0, 'finds no expressions');
+    t.equal(modules.nodes.length, 2, 'finds a node for each matching function call');
+    t.equal(
+      modules.nodes.filter(function (x) { 
+        return x.callee.name === 'fn' 
+      }).length, 2, 
+      'all matches are correct'
+    );
+});

static/js/ketcher2/node_modules/detective/test/parseopts.js

@@ -0,0 +1,62 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/both.js');
+
+test('nodes specified in opts and parseopts { range: true }', function (t) {
+    var modules = detective.find(src, { nodes: true, parse: { range: true } });
+    t.deepEqual(modules.strings, [ 'a', 'b' ]);
+    t.deepEqual(modules.expressions, [ "'c' + x", "'d' + y" ]);
+    t.deepEqual(
+      modules.nodes.map(function (n) { 
+        var arg = n.arguments[0];
+        return arg.value || arg.left.value; 
+      }),
+      [ 'a', 'b', 'c', 'd' ],
+      'has a node for each require');
+
+    var range = modules.nodes[0].range;
+    t.equal(range[0], 0, 'includes range start');
+    t.equal(range[1], 12, 'includes range end');
+    t.end();
+});
+
+test('nodes specified in opts and parseopts { range: false }', function (t) {
+    var modules = detective.find(src, { nodes: true, parse: { range: false } });
+    t.deepEqual(modules.strings, [ 'a', 'b' ]);
+    t.deepEqual(modules.expressions, [ "'c' + x", "'d' + y" ]);
+    t.deepEqual(
+      modules.nodes.map(function (n) { 
+        var arg = n.arguments[0];
+        return arg.value || arg.left.value; 
+      }),
+      [ 'a', 'b', 'c', 'd' ],
+      'has a node for each require');
+
+    t.notOk(modules.nodes[0].range, 'includes no ranges');
+    t.end();
+});
+
+test('nodes specified in opts and parseopts { range: true, loc: true }', function (t) {
+    var modules = detective.find(src, { nodes: true, parse: { range: true, loc: true } });
+    t.deepEqual(modules.strings, [ 'a', 'b' ]);
+    t.deepEqual(modules.expressions, [ "'c' + x", "'d' + y" ]);
+    t.deepEqual(
+      modules.nodes.map(function (n) { 
+        var arg = n.arguments[0];
+        return arg.value || arg.left.value; 
+      }),
+      [ 'a', 'b', 'c', 'd' ],
+      'has a node for each require');
+
+    var range = modules.nodes[0].range;
+    t.equal(range[0], 0, 'includes range start');
+    t.equal(range[1], 12, 'includes range end');
+
+    var loc = modules.nodes[0].loc;
+    t.equal(loc.start.line, 1, 'includes start line');
+    t.equal(loc.start.column, 0, 'includes start column');
+    t.equal(loc.end.line, 1, 'includes end line');
+    t.equal(loc.end.column, 12, 'includes end column');
+    t.end();
+});

static/js/ketcher2/node_modules/detective/test/return.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = [ 'require("a")\nreturn' ];
+
+test('return', function (t) {
+    t.plan(1);
+    t.deepEqual(detective(src), [ 'a' ]);
+});

static/js/ketcher2/node_modules/detective/test/shebang.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/shebang.js');
+
+test('shebang', function (t) {
+    t.plan(1);
+    t.deepEqual(detective(src), [ 'a', 'b', 'c' ]);
+});

static/js/ketcher2/node_modules/detective/test/sparse-array.js

@@ -0,0 +1,14 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/sparse-array.js');
+
+test('sparse-array', function (t) {
+    //just check that this does not crash.
+    t.doesNotThrow(function () {
+      detective(src)
+    })
+    t.end();
+});
+
+

static/js/ketcher2/node_modules/detective/test/strings.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/strings.js');
+
+test('single', function (t) {
+    t.deepEqual(detective(src), [ 'a', 'b', 'c', 'events', 'doom', 'y', 'events2' ]);
+    t.end();
+});

static/js/ketcher2/node_modules/detective/test/word.js

@@ -0,0 +1,12 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/word.js');
+
+test('word', function (t) {
+    t.deepEqual(
+        detective(src, { word : 'load' }),
+        [ 'a', 'b', 'c', 'events', 'doom', 'y', 'events2' ]
+    );
+    t.end();
+});

static/js/ketcher2/node_modules/detective/test/yield.js

@@ -0,0 +1,9 @@
+var test = require('tap').test;
+var detective = require('../');
+var fs = require('fs');
+var src = fs.readFileSync(__dirname + '/files/yield.js');
+
+test('yield', function (t) {
+    t.plan(1);
+    t.deepEqual(detective(src), [ 'a', 'c' ]);
+});