node_modules

node_modules/topo/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2012-2018, Project contributors
+Copyright (c) 2012-2014, Walmart
+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.
+    * The names of any contributors may not be used to endorse or promote
+      products derived from this software without specific prior written
+      permission.
+
+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 HOLDERS AND 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.

node_modules/topo/README.md

@@ -0,0 +1,29 @@
+# topo
+
+Topological sorting with grouping support.
+
+[![Build Status](https://secure.travis-ci.org/hapijs/topo.svg?branch=master)](http://travis-ci.org/hapijs/topo)
+
+Lead Maintainer: [Devin Ivy](https://github.com/devinivy)
+
+## Usage
+
+See the [API Reference](API.md)
+
+**Example**
+```js
+const Topo = require('topo');
+
+const morning = new Topo();
+
+morning.add('Nap', { after: ['breakfast', 'prep'] });
+
+morning.add([
+    'Make toast',
+    'Pour juice'
+], { before: 'breakfast', group: 'prep' });
+
+morning.add('Eat breakfast', { group: 'breakfast' });
+
+morning.nodes;        // ['Make toast', 'Pour juice', 'Eat breakfast', 'Nap']
+```

node_modules/topo/lib/index.js

@@ -0,0 +1,228 @@
+'use strict';
+
+// Load modules
+
+const Hoek = require('hoek');
+
+
+// Declare internals
+
+const internals = {};
+
+
+module.exports = class Topo {
+
+    constructor() {
+
+        this._items = [];
+        this.nodes = [];
+    }
+
+    add(nodes, options) {
+
+        options = options || {};
+
+        // Validate rules
+
+        const before = [].concat(options.before || []);
+        const after = [].concat(options.after || []);
+        const group = options.group || '?';
+        const sort = options.sort || 0;                   // Used for merging only
+
+        Hoek.assert(!before.includes(group), `Item cannot come before itself: ${group}`);
+        Hoek.assert(!before.includes('?'), 'Item cannot come before unassociated items');
+        Hoek.assert(!after.includes(group), `Item cannot come after itself: ${group}`);
+        Hoek.assert(!after.includes('?'), 'Item cannot come after unassociated items');
+
+        ([].concat(nodes)).forEach((node, i) => {
+
+            const item = {
+                seq: this._items.length,
+                sort,
+                before,
+                after,
+                group,
+                node
+            };
+
+            this._items.push(item);
+        });
+
+        // Insert event
+
+        const error = this._sort();
+        Hoek.assert(!error, 'item', (group !== '?' ? `added into group ${group}` : ''), 'created a dependencies error');
+
+        return this.nodes;
+    }
+
+    merge(others) {
+
+        others = [].concat(others);
+        for (let i = 0; i < others.length; ++i) {
+            const other = others[i];
+            if (other) {
+                for (let j = 0; j < other._items.length; ++j) {
+                    const item = Object.assign({}, other._items[j]);        // Shallow cloned
+                    this._items.push(item);
+                }
+            }
+        }
+
+        // Sort items
+
+        this._items.sort(internals.mergeSort);
+        for (let i = 0; i < this._items.length; ++i) {
+            this._items[i].seq = i;
+        }
+
+        const error = this._sort();
+        Hoek.assert(!error, 'merge created a dependencies error');
+
+        return this.nodes;
+    }
+
+    _sort() {
+
+        // Construct graph
+
+        const graph = {};
+        const graphAfters = Object.create(null); // A prototype can bungle lookups w/ false positives
+        const groups = Object.create(null);
+
+        for (let i = 0; i < this._items.length; ++i) {
+            const item = this._items[i];
+            const seq = item.seq;                         // Unique across all items
+            const group = item.group;
+
+            // Determine Groups
+
+            groups[group] = groups[group] || [];
+            groups[group].push(seq);
+
+            // Build intermediary graph using 'before'
+
+            graph[seq] = item.before;
+
+            // Build second intermediary graph with 'after'
+
+            const after = item.after;
+            for (let j = 0; j < after.length; ++j) {
+                graphAfters[after[j]] = (graphAfters[after[j]] || []).concat(seq);
+            }
+        }
+
+        // Expand intermediary graph
+
+        let graphNodes = Object.keys(graph);
+        for (let i = 0; i < graphNodes.length; ++i) {
+            const node = graphNodes[i];
+            const expandedGroups = [];
+
+            const graphNodeItems = Object.keys(graph[node]);
+            for (let j = 0; j < graphNodeItems.length; ++j) {
+                const group = graph[node][graphNodeItems[j]];
+                groups[group] = groups[group] || [];
+
+                for (let k = 0; k < groups[group].length; ++k) {
+                    expandedGroups.push(groups[group][k]);
+                }
+            }
+
+            graph[node] = expandedGroups;
+        }
+
+        // Merge intermediary graph using graphAfters into final graph
+
+        const afterNodes = Object.keys(graphAfters);
+        for (let i = 0; i < afterNodes.length; ++i) {
+            const group = afterNodes[i];
+
+            if (groups[group]) {
+                for (let j = 0; j < groups[group].length; ++j) {
+                    const node = groups[group][j];
+                    graph[node] = graph[node].concat(graphAfters[group]);
+                }
+            }
+        }
+
+        // Compile ancestors
+
+        let children;
+        const ancestors = {};
+        graphNodes = Object.keys(graph);
+        for (let i = 0; i < graphNodes.length; ++i) {
+            const node = graphNodes[i];
+            children = graph[node];
+
+            for (let j = 0; j < children.length; ++j) {
+                ancestors[children[j]] = (ancestors[children[j]] || []).concat(node);
+            }
+        }
+
+        // Topo sort
+
+        const visited = {};
+        const sorted = [];
+
+        for (let i = 0; i < this._items.length; ++i) {          // Really looping thru item.seq values out of order
+            let next = i;
+
+            if (ancestors[i]) {
+                next = null;
+                for (let j = 0; j < this._items.length; ++j) {  // As above, these are item.seq values
+                    if (visited[j] === true) {
+                        continue;
+                    }
+
+                    if (!ancestors[j]) {
+                        ancestors[j] = [];
+                    }
+
+                    const shouldSeeCount = ancestors[j].length;
+                    let seenCount = 0;
+                    for (let k = 0; k < shouldSeeCount; ++k) {
+                        if (visited[ancestors[j][k]]) {
+                            ++seenCount;
+                        }
+                    }
+
+                    if (seenCount === shouldSeeCount) {
+                        next = j;
+                        break;
+                    }
+                }
+            }
+
+            if (next !== null) {
+                visited[next] = true;
+                sorted.push(next);
+            }
+        }
+
+        if (sorted.length !== this._items.length) {
+            return new Error('Invalid dependencies');
+        }
+
+        const seqIndex = {};
+        for (let i = 0; i < this._items.length; ++i) {
+            const item = this._items[i];
+            seqIndex[item.seq] = item;
+        }
+
+        const sortedNodes = [];
+        this._items = sorted.map((value) => {
+
+            const sortedItem = seqIndex[value];
+            sortedNodes.push(sortedItem.node);
+            return sortedItem;
+        });
+
+        this.nodes = sortedNodes;
+    }
+};
+
+internals.mergeSort = (a, b) => {
+
+    return a.sort === b.sort ? 0 : (a.sort < b.sort ? -1 : 1);
+};

node_modules/topo/package.json

@@ -0,0 +1,57 @@
+{
+  "_from": "topo@3.x.x",
+  "_id": "topo@3.0.3",
+  "_inBundle": false,
+  "_integrity": "sha512-IgpPtvD4kjrJ7CRA3ov2FhWQADwv+Tdqbsf1ZnPUSAtCJ9e1Z44MmoSGDXGk4IppoZA7jd/QRkNddlLJWlUZsQ==",
+  "_location": "/topo",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "topo@3.x.x",
+    "name": "topo",
+    "escapedName": "topo",
+    "rawSpec": "3.x.x",
+    "saveSpec": null,
+    "fetchSpec": "3.x.x"
+  },
+  "_requiredBy": [
+    "/joi"
+  ],
+  "_resolved": "https://registry.npmjs.org/topo/-/topo-3.0.3.tgz",
+  "_shasum": "d5a67fb2e69307ebeeb08402ec2a2a6f5f7ad95c",
+  "_spec": "topo@3.x.x",
+  "_where": "D:\\Atom\\Git\\Laravel_CSSd\\node_modules\\joi",
+  "bugs": {
+    "url": "https://github.com/hapijs/topo/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "hoek": "6.x.x"
+  },
+  "deprecated": false,
+  "description": "Topological sorting with grouping support",
+  "devDependencies": {
+    "code": "5.x.x",
+    "lab": "17.x.x"
+  },
+  "homepage": "https://github.com/hapijs/topo#readme",
+  "keywords": [
+    "topological",
+    "sort",
+    "toposort",
+    "topsort"
+  ],
+  "license": "BSD-3-Clause",
+  "main": "lib/index.js",
+  "name": "topo",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/hapijs/topo.git"
+  },
+  "scripts": {
+    "test": "lab -a code -t 100 -L",
+    "test-cov-html": "lab -a code -t 100 -L -r html -o coverage.html"
+  },
+  "version": "3.0.3"
+}