Updates node_modules
DISABLE_THIRD_PARTY_CHECK=Package needs updating with node_modules
Change-Id: I889f1b86c586e37307a3e13ad762aa56d1ece150
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/1946468
Commit-Queue: Paul Lewis <aerotwist@chromium.org>
Reviewed-by: Tim van der Lippe <tvanderlippe@chromium.org>
diff --git a/node_modules/treeify/.travis.yml b/node_modules/treeify/.travis.yml
new file mode 100644
index 0000000..8a38a75
--- /dev/null
+++ b/node_modules/treeify/.travis.yml
@@ -0,0 +1,8 @@
+language: node_js
+node_js:
+ - "0.8"
+ # - "4"
+ # - "6"
+ # - "8"
+ # - "9"
+
diff --git a/node_modules/treeify/LICENSE b/node_modules/treeify/LICENSE
new file mode 100644
index 0000000..1df35f3
--- /dev/null
+++ b/node_modules/treeify/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2012-2018 Luke Plaster <notatestuser@gmail.com>
+
+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.
diff --git a/node_modules/treeify/README.md b/node_modules/treeify/README.md
new file mode 100644
index 0000000..63520f6
--- /dev/null
+++ b/node_modules/treeify/README.md
@@ -0,0 +1,77 @@
+treeify  
+=======
+
+[](https://travis-ci.org/notatestuser/treeify)
+
+_treeify_ converts a JS object into a nice, visible depth-indented tree for console printing. The structure
+generated is similar to what you get by running the ```tree``` command on Unixy platforms.
+
+```
+{
+ oranges: {
+ 'mandarin': { ├─ oranges
+ clementine: null, │ └─ mandarin
+ tangerine: 'so cheap and juicy!' -=> │ ├─ clementine
+ } │ └─ tangerine: so cheap and juicy!
+ }, └─ apples
+ apples: { ├─ gala
+ 'gala': null, └─ pink lady
+ 'pink lady': null
+ }
+}
+```
+
+It also works well with larger nested hierarchies such as file system directory trees.
+In fact, the ```fs_tree``` example does a pretty good job of imitating ```tree```. Try it out!
+
+See the other included examples or the test suite for usage scenarios.
+
+Getting it
+----------
+
+### For use with node.js
+
+First you'll want to run this command in your project's root folder:
+```
+$ npm install treeify
+```
+
+Then proceed to use it in your project:
+```js
+var treeify = require('treeify');
+console.log(
+ treeify.asTree({
+ apples: 'gala', // ├─ apples: gala
+ oranges: 'mandarin' // └─ oranges: mandarin
+ }, true)
+);
+```
+
+### For use in a browser
+
+Treeify cooperates with Node, AMD or browser globals to create a module. This means it'll work
+in a browser regardless of whether you have an AMD-compliant module loader or not. If such
+a loader isn't found when the script is executed, you may access Treeify at ```window.treeify```.
+
+Usage
+-----
+
+The methods exposed to you are as follows, in a strange kind of signature notation:
+
+### asLines()
+```js
+treeify.asLines(obj, showValues (boolean), [hideFunctions (boolean),] lineCallback (function))
+// NOTE: hideFunctions is optional and may be safely omitted - this was done to ensure we don't break uses of the previous form
+```
+### asTree()
+```js
+treeify.asTree(obj, showValues (boolean), hideFunctions (boolean)): String
+```
+
+Running the tests
+-----------------
+
+There's a pretty extensive suite of Vows tests included.
+```
+$ npm test
+```
diff --git a/node_modules/treeify/examples/eukaryotes.html b/node_modules/treeify/examples/eukaryotes.html
new file mode 100644
index 0000000..37ad1dc
--- /dev/null
+++ b/node_modules/treeify/examples/eukaryotes.html
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+
+ <script src="../treeify.js"></script>
+ <script>
+ // when a loader isn't present the UMD falls back to using a window 'global'
+ window.require = function() {
+ return window.treeify;
+ };
+ </script>
+ <script src="./eukaryotes.js"></script>
+
+ <style>
+ body {
+ display: block;
+ width: 630px;
+ margin: auto;
+ font-family: sans-serif;
+ }
+ </style>
+ </head>
+ <body>
+ <h1>Eukaryotes</h1>
+ <pre id="pre"></pre>
+ <script>
+ document.getElementById('pre').innerText = treeify.asTree(Eukaryotes, true);
+ </script>
+ </body>
+</html>
diff --git a/node_modules/treeify/examples/eukaryotes.js b/node_modules/treeify/examples/eukaryotes.js
new file mode 100755
index 0000000..8477e3e
--- /dev/null
+++ b/node_modules/treeify/examples/eukaryotes.js
@@ -0,0 +1,51 @@
+var treeify = require('../treeify');
+
+// Based on information taken from the Tree of Life web project
+// http://tolweb.org/Eukaryotes/3
+var Eukaryotes = {
+ 'Archaeplastida (Plantae)': {
+ 'Green plants': 'green algae & land plants',
+ 'Rhodophyta': 'red algae',
+ 'Glaucophytes': 'microalgae'
+ },
+ 'Unikonts': {
+ 'Opisthokonts': {
+ 'Animals': null,
+ 'Choanoflagellates': null,
+ 'Filasterea': null,
+ 'Ichthyosporea': null,
+ 'Fungi': 'mushrooms, sac fungi, yeast, molds, etc',
+ 'Nucleariidae': 'filose amoebae'
+ },
+ 'Amoebozoa': 'amoebae, slime molds, and parasitic protists',
+ },
+ 'Chromalveolates': {
+ '': {
+ 'Rhizaria': {
+ 'Cercozoa': 'amoeboflagellates',
+ 'Foraminifera': 'complex cells with reticulopodia',
+ 'Radiolaria': null
+ },
+ 'Alveolates': 'dinoflagellates, ciliates and apicomplexan parasites',
+ 'Stramenopiles': 'e.g. water molds, diatoms, brown algae'
+ },
+ 'Hacrobia': 'Haptophyta, Cryptomonads, etc.'
+ },
+ 'Excavates': {
+ 'Malawimonads': null,
+ 'Discicristates': {
+ 'Euglenozoa': 'euglenids, diplonemids and kinetoplastids',
+ 'Heterolobosea': 'amoeboflagellates with discoidal mitchondrial cristae',
+ 'Jakobida': 'free-living, heterotrophic flagellates'
+ },
+ 'Parabasalids': 'trichomonads and hypermastigotes',
+ 'Fornicata': 'diplomonads and retortamonads',
+ 'Preaxostyla': 'oxymonads and Trimastix'
+ }
+};
+
+console.log('Eukaryotes');
+
+treeify.asLines(Eukaryotes, true, function(line) {
+ console.log(line);
+});
diff --git a/node_modules/treeify/examples/fs_tree.js b/node_modules/treeify/examples/fs_tree.js
new file mode 100755
index 0000000..d1076ab
--- /dev/null
+++ b/node_modules/treeify/examples/fs_tree.js
@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+(function(){
+
+ try {
+ var dive = require('dive');
+ } catch (ex) {
+ console.error('this example requires "dive", please run "npm install dive"');
+ process.exit(1);
+ }
+
+ var treeify = require('../treeify'),
+ path = require('path'),
+ fs = require('fs'),
+ rootDir = process.argv.length < 3 ? '.' : process.argv[2],
+ tree = {};
+
+ if ( ! fs.existsSync(rootDir)) {
+ console.error('path "' + rootDir + '" does not exist - unable to proceed!');
+ process.exit(1);
+ }
+
+ console.log(rootDir !== '.' ? path.relative(process.cwd(), rootDir) : '.');
+
+ function scanComplete() {
+ process.stdout.write('\r \r');
+ console.log(treeify.asTree(tree, true));
+ }
+
+ dive(rootDir, { all: true, directories: true }, function(err, thisPath) {
+ var relativePath = path.relative(rootDir, thisPath),
+ node = tree;
+
+ if (relativePath.indexOf('..') !== 0) {
+ relativePath.split(path.sep).forEach(function(part) {
+ typeof node[part] !== 'object' && (node[part] = {});
+ node = node[part];
+ });
+ }
+
+ }, scanComplete);
+
+ process.stdout.write('wait... ');
+
+})();
diff --git a/node_modules/treeify/package.json b/node_modules/treeify/package.json
new file mode 100644
index 0000000..825709a
--- /dev/null
+++ b/node_modules/treeify/package.json
@@ -0,0 +1,34 @@
+{
+ "author": "Luke Plaster <notatestuser@gmail.com>",
+ "description": "converts a JS object into a nice and readable tree structure for the console",
+ "devDependencies": {
+ "vows": "git://github.com/Filirom1/vows.git#expect"
+ },
+ "engines": {
+ "node": ">=0.6"
+ },
+ "keywords": [
+ "object",
+ "tree",
+ "print",
+ "console",
+ "pretty"
+ ],
+ "license": "MIT",
+ "licenses": [
+ {
+ "type": "MIT",
+ "url": "http://lp.mit-license.org/"
+ }
+ ],
+ "main": "./treeify",
+ "name": "treeify",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/notatestuser/treeify.git"
+ },
+ "scripts": {
+ "test": "./node_modules/vows/bin/vows --spec"
+ },
+ "version": "1.1.0"
+}
\ No newline at end of file
diff --git a/node_modules/treeify/test/tree-test.js b/node_modules/treeify/test/tree-test.js
new file mode 100644
index 0000000..c5841e9
--- /dev/null
+++ b/node_modules/treeify/test/tree-test.js
@@ -0,0 +1,347 @@
+var treeify = require('../treeify'),
+ vows = require('vows'),
+ assert = require('assert'),
+ events = require('events');
+
+// - helper functions -----------------
+
+function treeifyByLineGuts(args) {
+ var emitter = new events.EventEmitter(),
+ lineNum = 0;
+ args.push(function(line) {
+ emitter.emit('success', line);
+ emitter.emit('line ' + (++lineNum), line);
+ });
+ treeify.asLines.apply(this, args);
+ return emitter;
+}
+
+function treeifyByLine(obj) {
+ return function(showValues) {
+ var arguments = [ obj, showValues ];
+ return treeifyByLineGuts(arguments);
+ };
+}
+
+function treeifyByLineWithHideFunctionsArgument(obj) {
+ return function(showValues, hideFunctions) {
+ var arguments = [ obj, showValues, hideFunctions ];
+ return treeifyByLineGuts(arguments);
+ };
+}
+
+function treeifyEntirely(obj) {
+ return function(showValues, hideFunctions) {
+ return treeify.asTree(obj, showValues, hideFunctions);
+ };
+}
+
+function withValuesShown(showValues) {
+ return function(func){ return func(showValues, false) };
+}
+
+function withValuesShownFunctionsHidden() {
+ return function(func){ return func(true, true) };
+
+}
+
+function is(content, arrayIndex) {
+ return function(lines) {
+ var toCheck = lines;
+ if (arrayIndex !== undefined) {
+ toCheck = lines[arrayIndex];
+ }
+ assert.strictEqual(toCheck, content, 'should be "' + content + '" but was "' + toCheck + '"');
+ };
+}
+
+function checkLines(/* ... */) {
+ var ret = {}, entry;
+ for (var line = 1; line <= arguments.length; line++) {
+ if ( ! arguments[line - 1])
+ continue;
+ entry = {};
+ entry['branches correctly on line '+line] = is(arguments[line - 1]);
+ ret['line '+line] = entry;
+ }
+ return ret;
+}
+
+// - the beautiful test suite ---------
+
+vows.describe('tree-test').addBatch({
+
+ 'A tree created from an empty object': {
+ topic: {},
+
+ 'when returned as a whole tree': {
+ topic: treeifyEntirely,
+
+ 'with values hidden': {
+ topic: withValuesShown(false),
+ 'is an empty string': is('')
+ },
+ 'with values shown': {
+ topic: withValuesShown(true),
+ 'is an empty string': is('')
+ }
+ }
+ },
+
+ 'A tree created from a single-level object': {
+ topic: {
+ apples: 'gala', // ├─ apples: gala
+ oranges: 'mandarin' // └─ oranges: mandarin
+ },
+
+ 'when returned line-by-line': {
+ topic: treeifyByLine,
+
+ 'with values hidden': {
+ topic: withValuesShown(false),
+
+ 'is two lines long': function(err, line) {
+ this.expect(2);
+ },
+ on: checkLines('├─ apples',
+ '└─ oranges')
+ },
+ 'with values shown': {
+ topic: withValuesShown(true),
+
+ 'is two lines long': function(err, line) {
+ this.expect(2);
+ },
+ on: checkLines('├─ apples: gala',
+ '└─ oranges: mandarin')
+ }
+ },
+
+ 'when returned as a whole tree': {
+ topic: treeifyEntirely,
+
+ 'with values hidden': {
+ topic: withValuesShown(false),
+
+ 'is not empty': function(tree) {
+ assert.notEqual(tree, '', 'should not be empty');
+ },
+ 'contains 2 line breaks': function(tree) {
+ assert.strictEqual(tree.match(/\n/g).length, 2, 'should contain 2 x \n');
+ },
+ '(split into an array of lines)': {
+ topic: function(tree) { return tree.split(/\n/g) },
+ 'has a correct first line': is('├─ apples', 0),
+ 'has a correct second line': is('└─ oranges', 1),
+ 'has nothing at the end': is('', 2)
+ }
+ },
+ 'with values shown': {
+ topic: withValuesShown(true),
+
+ 'is not empty': function(tree) {
+ assert.notEqual(tree, '', 'should not be empty');
+ },
+ 'contains 2 line breaks': function(tree) {
+ assert.strictEqual(tree.match(/\n/g).length, 2, 'should contain 2 x \n');
+ },
+ '(split into an array of lines)': {
+ topic: function(tree) { return tree.split(/\n/g) },
+ 'has a correct first line': is('├─ apples: gala', 0),
+ 'has a correct second line': is('└─ oranges: mandarin', 1),
+ 'has nothing at the end': is('', 2)
+ }
+ }
+ }
+ },
+
+ 'A tree created from a multi-level object': {
+ topic: {
+ oranges: { // ├─ oranges
+ 'mandarin': { // │ └─ mandarin
+ clementine: null, // │ ├─ clementine
+ tangerine: // │ └─ tangerine
+ 'so cheap and juicy!'
+ }
+ },
+ apples: { // └─ apples
+ 'gala': null, // ├─ gala
+ 'pink lady': null // └─ pink lady
+ }
+ },
+
+ 'when returned line-by-line': {
+ topic: treeifyByLine,
+
+ 'with values hidden': {
+ topic: withValuesShown(false),
+
+ 'is seven lines long': function(err, line) {
+ this.expect(7);
+ },
+ on: checkLines('├─ oranges',
+ '│ └─ mandarin',
+ '│ ├─ clementine',
+ '│ └─ tangerine',
+ '└─ apples',
+ ' ├─ gala',
+ ' └─ pink lady')
+ },
+ 'with values shown': {
+ topic: withValuesShown(true),
+ on: checkLines(null, null, null,
+ '│ └─ tangerine: so cheap and juicy!')
+ }
+ },
+
+ 'when returned as a whole tree': {
+ topic: treeifyEntirely,
+
+ 'with values shown': {
+ topic: withValuesShown(true),
+
+ '(split into an array of lines)': {
+ topic: function(tree) { return tree.split(/\n/g) },
+ 'has a correct first line': is('├─ oranges', 0),
+ 'has a correct third line': is('│ └─ tangerine: so cheap and juicy!', 3),
+ 'has nothing at the end': is('', 7)
+ }
+ }
+ }
+ },
+
+ 'A tree created from an object with not so circular references': {
+ topic: function() {
+ var obj = { one: 'one', two: { four: 'four' } };
+ obj['three'] = obj.two;
+ return obj;
+ },
+
+ 'when returned line-by-line': {
+ topic: treeifyByLine,
+
+ 'with values shown': {
+ topic: withValuesShown(true),
+ on: checkLines('├─ one: one',
+ '├─ two',
+ '│ └─ four: four',
+ '└─ three',
+ ' └─ four: four')
+ }
+ }
+ },
+
+ 'A tree created from an object with circular references': {
+ topic: function() {
+ var obj = { one: 'one', two: 'two' };
+ obj['three'] = obj;
+ return obj;
+ },
+
+ 'when returned line-by-line': {
+ topic: treeifyByLine,
+
+ 'with values shown': {
+ topic: withValuesShown(true),
+ on: checkLines('├─ one: one',
+ '├─ two: two',
+ '└─ three (circular ref.)')
+ }
+ }
+ },
+
+ 'A tree created from an object containing various types': {
+ topic: {
+ array: [ 'one', 'two' ],
+ numeric: 42,
+ decimal: 42.24,
+ bool: false,
+ nil: null,
+ undef: undefined,
+ date: new Date(2018,0,1)
+ },
+
+ 'when returned line-by-line': {
+ topic: treeifyByLine,
+
+ 'with values shown': {
+ topic: withValuesShown(true),
+ on: checkLines('├─ array',
+ '│ ├─ 0: one',
+ '│ └─ 1: two',
+ '├─ numeric: 42',
+ '├─ decimal: 42.24',
+ '├─ bool: false',
+ '├─ nil',
+ '├─ undef: undefined',
+ '└─ date: Mon Jan 01 2018 00:00:00 GMT+0000 (UTC)')
+ }
+ }
+ },
+
+ 'A tree created from an object with prototyped functions': {
+ topic: function() {
+ var func = function(){
+ this.Friendly = 'stuff';
+ }
+ func.prototype.Nasty = function(){}
+ return new func();
+ },
+
+ 'when returned as a whole tree': {
+ topic: treeifyEntirely,
+
+ 'with values shown': {
+ topic: withValuesShown(true),
+
+ 'and split into an array of lines': {
+ topic: function(tree) { return tree.split(/\n/g) },
+ 'is a one liner output (with a following blank line)': function(lines) {
+ assert.equal(lines.length, 2);
+ },
+ 'has a correct first line': is('└─ Friendly: stuff', 0)
+ }
+ }
+ }
+ },
+ 'A tree with functions': {
+ topic: {
+ func:function(){},
+ Friendly:"stuff",
+ Another:"stuff"
+ },
+
+ 'when returned line-by-line': {
+ topic: treeifyByLineWithHideFunctionsArgument,
+
+ 'with values shown, but functions hidden': {
+ topic: withValuesShownFunctionsHidden(),
+
+ 'is two lines long': function(err, line) {
+ this.expect(2);
+ },
+ on: checkLines('├─ Friendly: stuff',
+ '└─ Another: stuff')
+ }
+ },
+
+ 'when returned as a whole tree': {
+ topic: treeifyEntirely,
+
+ 'with values shown, but functions hidden': {
+ topic: withValuesShownFunctionsHidden(),
+
+ 'and split into an array of lines': {
+ topic: function(tree) {
+ console.error(tree);
+ return tree.split(/\n/g) },
+ 'is a one liner output (with a following blank line)': function(lines) {
+ assert.equal(lines.length, 3);
+ },
+ 'has a correct first line': is('├─ Friendly: stuff', 0)
+ }
+ }
+ }
+ }
+
+}).export(module);
diff --git a/node_modules/treeify/treeify.js b/node_modules/treeify/treeify.js
new file mode 100644
index 0000000..17fb428
--- /dev/null
+++ b/node_modules/treeify/treeify.js
@@ -0,0 +1,113 @@
+// treeify.js
+// Luke Plaster <notatestuser@gmail.com>
+// https://github.com/notatestuser/treeify.js
+
+// do the universal module definition dance
+(function (root, factory) {
+
+ if (typeof exports === 'object') {
+ module.exports = factory();
+ } else if (typeof define === 'function' && define.amd) {
+ define(factory);
+ } else {
+ root.treeify = factory();
+ }
+
+}(this, function() {
+
+ function makePrefix(key, last) {
+ var str = (last ? '└' : '├');
+ if (key) {
+ str += '─ ';
+ } else {
+ str += '──┐';
+ }
+ return str;
+ }
+
+ function filterKeys(obj, hideFunctions) {
+ var keys = [];
+ for (var branch in obj) {
+ // always exclude anything in the object's prototype
+ if (!obj.hasOwnProperty(branch)) {
+ continue;
+ }
+ // ... and hide any keys mapped to functions if we've been told to
+ if (hideFunctions && ((typeof obj[branch])==="function")) {
+ continue;
+ }
+ keys.push(branch);
+ }
+ return keys;
+ }
+
+ function growBranch(key, root, last, lastStates, showValues, hideFunctions, callback) {
+ var line = '', index = 0, lastKey, circular, lastStatesCopy = lastStates.slice(0);
+
+ if (lastStatesCopy.push([ root, last ]) && lastStates.length > 0) {
+ // based on the "was last element" states of whatever we're nested within,
+ // we need to append either blankness or a branch to our line
+ lastStates.forEach(function(lastState, idx) {
+ if (idx > 0) {
+ line += (lastState[1] ? ' ' : '│') + ' ';
+ }
+ if ( ! circular && lastState[0] === root) {
+ circular = true;
+ }
+ });
+
+ // the prefix varies based on whether the key contains something to show and
+ // whether we're dealing with the last element in this collection
+ line += makePrefix(key, last) + key;
+
+ // append values and the circular reference indicator
+ showValues && (typeof root !== 'object' || root instanceof Date) && (line += ': ' + root);
+ circular && (line += ' (circular ref.)');
+
+ callback(line);
+ }
+
+ // can we descend into the next item?
+ if ( ! circular && typeof root === 'object') {
+ var keys = filterKeys(root, hideFunctions);
+ keys.forEach(function(branch){
+ // the last key is always printed with a different prefix, so we'll need to know if we have it
+ lastKey = ++index === keys.length;
+
+ // hold your breath for recursive action
+ growBranch(branch, root[branch], lastKey, lastStatesCopy, showValues, hideFunctions, callback);
+ });
+ }
+ };
+
+ // --------------------
+
+ var Treeify = {};
+
+ // Treeify.asLines
+ // --------------------
+ // Outputs the tree line-by-line, calling the lineCallback when each one is available.
+
+ Treeify.asLines = function(obj, showValues, hideFunctions, lineCallback) {
+ /* hideFunctions and lineCallback are curried, which means we don't break apps using the older form */
+ var hideFunctionsArg = typeof hideFunctions !== 'function' ? hideFunctions : false;
+ growBranch('.', obj, false, [], showValues, hideFunctionsArg, lineCallback || hideFunctions);
+ };
+
+ // Treeify.asTree
+ // --------------------
+ // Outputs the entire tree, returning it as a string with line breaks.
+
+ Treeify.asTree = function(obj, showValues, hideFunctions) {
+ var tree = '';
+ growBranch('.', obj, false, [], showValues, hideFunctions, function(line) {
+ tree += line + '\n';
+ });
+ return tree;
+ };
+
+ // --------------------
+
+ return Treeify;
+
+}));