Index: frontend/node_modules/symbol-tree/lib/SymbolTree.js =================================================================== --- frontend/node_modules/symbol-tree/lib/SymbolTree.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/symbol-tree/lib/SymbolTree.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,838 @@ +'use strict'; + +/** + * @module symbol-tree + * @author Joris van der Wel + */ + +const SymbolTreeNode = require('./SymbolTreeNode'); +const TreePosition = require('./TreePosition'); +const TreeIterator = require('./TreeIterator'); + +function returnTrue() { + return true; +} + +function reverseArrayIndex(array, reverseIndex) { + return array[array.length - 1 - reverseIndex]; // no need to check `index >= 0` +} + +class SymbolTree { + + /** + * @constructor + * @alias module:symbol-tree + * @param {string} [description='SymbolTree data'] Description used for the Symbol + */ + constructor(description) { + this.symbol = Symbol(description || 'SymbolTree data'); + } + + /** + * You can use this function to (optionally) initialize an object right after its creation, + * to take advantage of V8's fast properties. Also useful if you would like to + * freeze your object. + * + * `O(1)` + * + * @method + * @alias module:symbol-tree#initialize + * @param {Object} object + * @return {Object} object + */ + initialize(object) { + this._node(object); + + return object; + } + + _node(object) { + if (!object) { + return null; + } + + const node = object[this.symbol]; + + if (node) { + return node; + } + + return (object[this.symbol] = new SymbolTreeNode()); + } + + /** + * Returns `true` if the object has any children. Otherwise it returns `false`. + * + * * `O(1)` + * + * @method hasChildren + * @memberOf module:symbol-tree# + * @param {Object} object + * @return {Boolean} + */ + hasChildren(object) { + return this._node(object).hasChildren; + } + + /** + * Returns the first child of the given object. + * + * * `O(1)` + * + * @method firstChild + * @memberOf module:symbol-tree# + * @param {Object} object + * @return {Object} + */ + firstChild(object) { + return this._node(object).firstChild; + } + + /** + * Returns the last child of the given object. + * + * * `O(1)` + * + * @method lastChild + * @memberOf module:symbol-tree# + * @param {Object} object + * @return {Object} + */ + lastChild(object) { + return this._node(object).lastChild; + } + + /** + * Returns the previous sibling of the given object. + * + * * `O(1)` + * + * @method previousSibling + * @memberOf module:symbol-tree# + * @param {Object} object + * @return {Object} + */ + previousSibling(object) { + return this._node(object).previousSibling; + } + + /** + * Returns the next sibling of the given object. + * + * * `O(1)` + * + * @method nextSibling + * @memberOf module:symbol-tree# + * @param {Object} object + * @return {Object} + */ + nextSibling(object) { + return this._node(object).nextSibling; + } + + /** + * Return the parent of the given object. + * + * * `O(1)` + * + * @method parent + * @memberOf module:symbol-tree# + * @param {Object} object + * @return {Object} + */ + parent(object) { + return this._node(object).parent; + } + + /** + * Find the inclusive descendant that is last in tree order of the given object. + * + * * `O(n)` (worst case) where `n` is the depth of the subtree of `object` + * + * @method lastInclusiveDescendant + * @memberOf module:symbol-tree# + * @param {Object} object + * @return {Object} + */ + lastInclusiveDescendant(object) { + let lastChild; + let current = object; + + while ((lastChild = this._node(current).lastChild)) { + current = lastChild; + } + + return current; + } + + /** + * Find the preceding object (A) of the given object (B). + * An object A is preceding an object B if A and B are in the same tree + * and A comes before B in tree order. + * + * * `O(n)` (worst case) + * * `O(1)` (amortized when walking the entire tree) + * + * @method preceding + * @memberOf module:symbol-tree# + * @param {Object} object + * @param {Object} [options] + * @param {Object} [options.root] If set, `root` must be an inclusive ancestor + * of the return value (or else null is returned). This check _assumes_ + * that `root` is also an inclusive ancestor of the given `object` + * @return {?Object} + */ + preceding(object, options) { + const treeRoot = options && options.root; + + if (object === treeRoot) { + return null; + } + + const previousSibling = this._node(object).previousSibling; + + if (previousSibling) { + return this.lastInclusiveDescendant(previousSibling); + } + + // if there is no previous sibling return the parent (might be null) + return this._node(object).parent; + } + + /** + * Find the following object (A) of the given object (B). + * An object A is following an object B if A and B are in the same tree + * and A comes after B in tree order. + * + * * `O(n)` (worst case) where `n` is the amount of objects in the entire tree + * * `O(1)` (amortized when walking the entire tree) + * + * @method following + * @memberOf module:symbol-tree# + * @param {!Object} object + * @param {Object} [options] + * @param {Object} [options.root] If set, `root` must be an inclusive ancestor + * of the return value (or else null is returned). This check _assumes_ + * that `root` is also an inclusive ancestor of the given `object` + * @param {Boolean} [options.skipChildren=false] If set, ignore the children of `object` + * @return {?Object} + */ + following(object, options) { + const treeRoot = options && options.root; + const skipChildren = options && options.skipChildren; + + const firstChild = !skipChildren && this._node(object).firstChild; + + if (firstChild) { + return firstChild; + } + + let current = object; + + do { + if (current === treeRoot) { + return null; + } + + const nextSibling = this._node(current).nextSibling; + + if (nextSibling) { + return nextSibling; + } + + current = this._node(current).parent; + } while (current); + + return null; + } + + /** + * Append all children of the given object to an array. + * + * * `O(n)` where `n` is the amount of children of the given `parent` + * + * @method childrenToArray + * @memberOf module:symbol-tree# + * @param {Object} parent + * @param {Object} [options] + * @param {Object[]} [options.array=[]] + * @param {Function} [options.filter] Function to test each object before it is added to the array. + * Invoked with arguments (object). Should return `true` if an object + * is to be included. + * @param {*} [options.thisArg] Value to use as `this` when executing `filter`. + * @return {Object[]} + */ + childrenToArray(parent, options) { + const array = (options && options.array) || []; + const filter = (options && options.filter) || returnTrue; + const thisArg = (options && options.thisArg) || undefined; + + const parentNode = this._node(parent); + let object = parentNode.firstChild; + let index = 0; + + while (object) { + const node = this._node(object); + node.setCachedIndex(parentNode, index); + + if (filter.call(thisArg, object)) { + array.push(object); + } + + object = node.nextSibling; + ++index; + } + + return array; + } + + /** + * Append all inclusive ancestors of the given object to an array. + * + * * `O(n)` where `n` is the amount of ancestors of the given `object` + * + * @method ancestorsToArray + * @memberOf module:symbol-tree# + * @param {Object} object + * @param {Object} [options] + * @param {Object[]} [options.array=[]] + * @param {Function} [options.filter] Function to test each object before it is added to the array. + * Invoked with arguments (object). Should return `true` if an object + * is to be included. + * @param {*} [options.thisArg] Value to use as `this` when executing `filter`. + * @return {Object[]} + */ + ancestorsToArray(object, options) { + const array = (options && options.array) || []; + const filter = (options && options.filter) || returnTrue; + const thisArg = (options && options.thisArg) || undefined; + + let ancestor = object; + + while (ancestor) { + if (filter.call(thisArg, ancestor)) { + array.push(ancestor); + } + ancestor = this._node(ancestor).parent; + } + + return array; + } + + /** + * Append all descendants of the given object to an array (in tree order). + * + * * `O(n)` where `n` is the amount of objects in the sub-tree of the given `object` + * + * @method treeToArray + * @memberOf module:symbol-tree# + * @param {Object} root + * @param {Object} [options] + * @param {Object[]} [options.array=[]] + * @param {Function} [options.filter] Function to test each object before it is added to the array. + * Invoked with arguments (object). Should return `true` if an object + * is to be included. + * @param {*} [options.thisArg] Value to use as `this` when executing `filter`. + * @return {Object[]} + */ + treeToArray(root, options) { + const array = (options && options.array) || []; + const filter = (options && options.filter) || returnTrue; + const thisArg = (options && options.thisArg) || undefined; + + let object = root; + + while (object) { + if (filter.call(thisArg, object)) { + array.push(object); + } + object = this.following(object, {root: root}); + } + + return array; + } + + /** + * Iterate over all children of the given object + * + * * `O(1)` for a single iteration + * + * @method childrenIterator + * @memberOf module:symbol-tree# + * @param {Object} parent + * @param {Object} [options] + * @param {Boolean} [options.reverse=false] + * @return {Object} An iterable iterator (ES6) + */ + childrenIterator(parent, options) { + const reverse = options && options.reverse; + const parentNode = this._node(parent); + + return new TreeIterator( + this, + parent, + reverse ? parentNode.lastChild : parentNode.firstChild, + reverse ? TreeIterator.PREV : TreeIterator.NEXT + ); + } + + /** + * Iterate over all the previous siblings of the given object. (in reverse tree order) + * + * * `O(1)` for a single iteration + * + * @method previousSiblingsIterator + * @memberOf module:symbol-tree# + * @param {Object} object + * @return {Object} An iterable iterator (ES6) + */ + previousSiblingsIterator(object) { + return new TreeIterator( + this, + object, + this._node(object).previousSibling, + TreeIterator.PREV + ); + } + + /** + * Iterate over all the next siblings of the given object. (in tree order) + * + * * `O(1)` for a single iteration + * + * @method nextSiblingsIterator + * @memberOf module:symbol-tree# + * @param {Object} object + * @return {Object} An iterable iterator (ES6) + */ + nextSiblingsIterator(object) { + return new TreeIterator( + this, + object, + this._node(object).nextSibling, + TreeIterator.NEXT + ); + } + + /** + * Iterate over all inclusive ancestors of the given object + * + * * `O(1)` for a single iteration + * + * @method ancestorsIterator + * @memberOf module:symbol-tree# + * @param {Object} object + * @return {Object} An iterable iterator (ES6) + */ + ancestorsIterator(object) { + return new TreeIterator( + this, + object, + object, + TreeIterator.PARENT + ); + } + + /** + * Iterate over all descendants of the given object (in tree order). + * + * Where `n` is the amount of objects in the sub-tree of the given `root`: + * + * * `O(n)` (worst case for a single iteration) + * * `O(n)` (amortized, when completing the iterator) + * + * @method treeIterator + * @memberOf module:symbol-tree# + * @param {Object} root + * @param {Object} options + * @param {Boolean} [options.reverse=false] + * @return {Object} An iterable iterator (ES6) + */ + treeIterator(root, options) { + const reverse = options && options.reverse; + + return new TreeIterator( + this, + root, + reverse ? this.lastInclusiveDescendant(root) : root, + reverse ? TreeIterator.PRECEDING : TreeIterator.FOLLOWING + ); + } + + /** + * Find the index of the given object (the number of preceding siblings). + * + * * `O(n)` where `n` is the amount of preceding siblings + * * `O(1)` (amortized, if the tree is not modified) + * + * @method index + * @memberOf module:symbol-tree# + * @param {Object} child + * @return {Number} The number of preceding siblings, or -1 if the object has no parent + */ + index(child) { + const childNode = this._node(child); + const parentNode = this._node(childNode.parent); + + if (!parentNode) { + // In principal, you could also find out the number of preceding siblings + // for objects that do not have a parent. This method limits itself only to + // objects that have a parent because that lets us optimize more. + return -1; + } + + let currentIndex = childNode.getCachedIndex(parentNode); + + if (currentIndex >= 0) { + return currentIndex; + } + + currentIndex = 0; + let object = parentNode.firstChild; + + if (parentNode.childIndexCachedUpTo) { + const cachedUpToNode = this._node(parentNode.childIndexCachedUpTo); + object = cachedUpToNode.nextSibling; + currentIndex = cachedUpToNode.getCachedIndex(parentNode) + 1; + } + + while (object) { + const node = this._node(object); + node.setCachedIndex(parentNode, currentIndex); + + if (object === child) { + break; + } + + ++currentIndex; + object = node.nextSibling; + } + + parentNode.childIndexCachedUpTo = child; + + return currentIndex; + } + + /** + * Calculate the number of children. + * + * * `O(n)` where `n` is the amount of children + * * `O(1)` (amortized, if the tree is not modified) + * + * @method childrenCount + * @memberOf module:symbol-tree# + * @param {Object} parent + * @return {Number} + */ + childrenCount(parent) { + const parentNode = this._node(parent); + + if (!parentNode.lastChild) { + return 0; + } + + return this.index(parentNode.lastChild) + 1; + } + + /** + * Compare the position of an object relative to another object. A bit set is returned: + * + * + * + * The semantics are the same as compareDocumentPosition in DOM, with the exception that + * DISCONNECTED never occurs with any other bit. + * + * where `n` and `m` are the amount of ancestors of `left` and `right`; + * where `o` is the amount of children of the lowest common ancestor of `left` and `right`: + * + * * `O(n + m + o)` (worst case) + * * `O(n + m)` (amortized, if the tree is not modified) + * + * @method compareTreePosition + * @memberOf module:symbol-tree# + * @param {Object} left + * @param {Object} right + * @return {Number} + */ + compareTreePosition(left, right) { + // In DOM terms: + // left = reference / context object + // right = other + + if (left === right) { + return 0; + } + + /* jshint -W016 */ + + const leftAncestors = []; { // inclusive + let leftAncestor = left; + + while (leftAncestor) { + if (leftAncestor === right) { + return TreePosition.CONTAINS | TreePosition.PRECEDING; + // other is ancestor of reference + } + + leftAncestors.push(leftAncestor); + leftAncestor = this.parent(leftAncestor); + } + } + + + const rightAncestors = []; { + let rightAncestor = right; + + while (rightAncestor) { + if (rightAncestor === left) { + return TreePosition.CONTAINED_BY | TreePosition.FOLLOWING; + } + + rightAncestors.push(rightAncestor); + rightAncestor = this.parent(rightAncestor); + } + } + + + const root = reverseArrayIndex(leftAncestors, 0); + + if (!root || root !== reverseArrayIndex(rightAncestors, 0)) { + // note: unlike DOM, preceding / following is not set here + return TreePosition.DISCONNECTED; + } + + // find the lowest common ancestor + let commonAncestorIndex = 0; + const ancestorsMinLength = Math.min(leftAncestors.length, rightAncestors.length); + + for (let i = 0; i < ancestorsMinLength; ++i) { + const leftAncestor = reverseArrayIndex(leftAncestors, i); + const rightAncestor = reverseArrayIndex(rightAncestors, i); + + if (leftAncestor !== rightAncestor) { + break; + } + + commonAncestorIndex = i; + } + + // indexes within the common ancestor + const leftIndex = this.index(reverseArrayIndex(leftAncestors, commonAncestorIndex + 1)); + const rightIndex = this.index(reverseArrayIndex(rightAncestors, commonAncestorIndex + 1)); + + return rightIndex < leftIndex + ? TreePosition.PRECEDING + : TreePosition.FOLLOWING; + } + + /** + * Remove the object from this tree. + * Has no effect if already removed. + * + * * `O(1)` + * + * @method remove + * @memberOf module:symbol-tree# + * @param {Object} removeObject + * @return {Object} removeObject + */ + remove(removeObject) { + const removeNode = this._node(removeObject); + const parentNode = this._node(removeNode.parent); + const prevNode = this._node(removeNode.previousSibling); + const nextNode = this._node(removeNode.nextSibling); + + if (parentNode) { + if (parentNode.firstChild === removeObject) { + parentNode.firstChild = removeNode.nextSibling; + } + + if (parentNode.lastChild === removeObject) { + parentNode.lastChild = removeNode.previousSibling; + } + } + + if (prevNode) { + prevNode.nextSibling = removeNode.nextSibling; + } + + if (nextNode) { + nextNode.previousSibling = removeNode.previousSibling; + } + + removeNode.parent = null; + removeNode.previousSibling = null; + removeNode.nextSibling = null; + removeNode.cachedIndex = -1; + removeNode.cachedIndexVersion = NaN; + + if (parentNode) { + parentNode.childrenChanged(); + } + + return removeObject; + } + + /** + * Insert the given object before the reference object. + * `newObject` is now the previous sibling of `referenceObject`. + * + * * `O(1)` + * + * @method insertBefore + * @memberOf module:symbol-tree# + * @param {Object} referenceObject + * @param {Object} newObject + * @throws {Error} If the newObject is already present in this SymbolTree + * @return {Object} newObject + */ + insertBefore(referenceObject, newObject) { + const referenceNode = this._node(referenceObject); + const prevNode = this._node(referenceNode.previousSibling); + const newNode = this._node(newObject); + const parentNode = this._node(referenceNode.parent); + + if (newNode.isAttached) { + throw Error('Given object is already present in this SymbolTree, remove it first'); + } + + newNode.parent = referenceNode.parent; + newNode.previousSibling = referenceNode.previousSibling; + newNode.nextSibling = referenceObject; + referenceNode.previousSibling = newObject; + + if (prevNode) { + prevNode.nextSibling = newObject; + } + + if (parentNode && parentNode.firstChild === referenceObject) { + parentNode.firstChild = newObject; + } + + if (parentNode) { + parentNode.childrenChanged(); + } + + return newObject; + } + + /** + * Insert the given object after the reference object. + * `newObject` is now the next sibling of `referenceObject`. + * + * * `O(1)` + * + * @method insertAfter + * @memberOf module:symbol-tree# + * @param {Object} referenceObject + * @param {Object} newObject + * @throws {Error} If the newObject is already present in this SymbolTree + * @return {Object} newObject + */ + insertAfter(referenceObject, newObject) { + const referenceNode = this._node(referenceObject); + const nextNode = this._node(referenceNode.nextSibling); + const newNode = this._node(newObject); + const parentNode = this._node(referenceNode.parent); + + if (newNode.isAttached) { + throw Error('Given object is already present in this SymbolTree, remove it first'); + } + + newNode.parent = referenceNode.parent; + newNode.previousSibling = referenceObject; + newNode.nextSibling = referenceNode.nextSibling; + referenceNode.nextSibling = newObject; + + if (nextNode) { + nextNode.previousSibling = newObject; + } + + if (parentNode && parentNode.lastChild === referenceObject) { + parentNode.lastChild = newObject; + } + + if (parentNode) { + parentNode.childrenChanged(); + } + + return newObject; + } + + /** + * Insert the given object as the first child of the given reference object. + * `newObject` is now the first child of `referenceObject`. + * + * * `O(1)` + * + * @method prependChild + * @memberOf module:symbol-tree# + * @param {Object} referenceObject + * @param {Object} newObject + * @throws {Error} If the newObject is already present in this SymbolTree + * @return {Object} newObject + */ + prependChild(referenceObject, newObject) { + const referenceNode = this._node(referenceObject); + const newNode = this._node(newObject); + + if (newNode.isAttached) { + throw Error('Given object is already present in this SymbolTree, remove it first'); + } + + if (referenceNode.hasChildren) { + this.insertBefore(referenceNode.firstChild, newObject); + } + else { + newNode.parent = referenceObject; + referenceNode.firstChild = newObject; + referenceNode.lastChild = newObject; + referenceNode.childrenChanged(); + } + + return newObject; + } + + /** + * Insert the given object as the last child of the given reference object. + * `newObject` is now the last child of `referenceObject`. + * + * * `O(1)` + * + * @method appendChild + * @memberOf module:symbol-tree# + * @param {Object} referenceObject + * @param {Object} newObject + * @throws {Error} If the newObject is already present in this SymbolTree + * @return {Object} newObject + */ + appendChild(referenceObject, newObject) { + const referenceNode = this._node(referenceObject); + const newNode = this._node(newObject); + + if (newNode.isAttached) { + throw Error('Given object is already present in this SymbolTree, remove it first'); + } + + if (referenceNode.hasChildren) { + this.insertAfter(referenceNode.lastChild, newObject); + } + else { + newNode.parent = referenceObject; + referenceNode.firstChild = newObject; + referenceNode.lastChild = newObject; + referenceNode.childrenChanged(); + } + + return newObject; + } +} + +module.exports = SymbolTree; +SymbolTree.TreePosition = TreePosition; Index: frontend/node_modules/symbol-tree/lib/SymbolTreeNode.js =================================================================== --- frontend/node_modules/symbol-tree/lib/SymbolTreeNode.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/symbol-tree/lib/SymbolTreeNode.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,54 @@ +'use strict'; + +module.exports = class SymbolTreeNode { + constructor() { + this.parent = null; + this.previousSibling = null; + this.nextSibling = null; + + this.firstChild = null; + this.lastChild = null; + + /** This value is incremented anytime a children is added or removed */ + this.childrenVersion = 0; + /** The last child object which has a cached index */ + this.childIndexCachedUpTo = null; + + /** This value represents the cached node index, as long as + * cachedIndexVersion matches with the childrenVersion of the parent */ + this.cachedIndex = -1; + this.cachedIndexVersion = NaN; // NaN is never equal to anything + } + + get isAttached() { + return Boolean(this.parent || this.previousSibling || this.nextSibling); + } + + get hasChildren() { + return Boolean(this.firstChild); + } + + childrenChanged() { + /* jshint -W016 */ + // integer wrap around + this.childrenVersion = (this.childrenVersion + 1) & 0xFFFFFFFF; + this.childIndexCachedUpTo = null; + } + + getCachedIndex(parentNode) { + // (assumes parentNode is actually the parent) + if (this.cachedIndexVersion !== parentNode.childrenVersion) { + this.cachedIndexVersion = NaN; + // cachedIndex is no longer valid + return -1; + } + + return this.cachedIndex; // -1 if not cached + } + + setCachedIndex(parentNode, index) { + // (assumes parentNode is actually the parent) + this.cachedIndexVersion = parentNode.childrenVersion; + this.cachedIndex = index; + } +}; Index: frontend/node_modules/symbol-tree/lib/TreeIterator.js =================================================================== --- frontend/node_modules/symbol-tree/lib/TreeIterator.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/symbol-tree/lib/TreeIterator.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,69 @@ +'use strict'; + +const TREE = Symbol(); +const ROOT = Symbol(); +const NEXT = Symbol(); +const ITERATE_FUNC = Symbol(); + +class TreeIterator { + constructor(tree, root, firstResult, iterateFunction) { + this[TREE] = tree; + this[ROOT] = root; + this[NEXT] = firstResult; + this[ITERATE_FUNC] = iterateFunction; + } + + next() { + const tree = this[TREE]; + const iterateFunc = this[ITERATE_FUNC]; + const root = this[ROOT]; + + if (!this[NEXT]) { + return { + done: true, + value: root, + }; + } + + const value = this[NEXT]; + + if (iterateFunc === 1) { + this[NEXT] = tree._node(value).previousSibling; + } + else if (iterateFunc === 2) { + this[NEXT] = tree._node(value).nextSibling; + } + else if (iterateFunc === 3) { + this[NEXT] = tree._node(value).parent; + } + else if (iterateFunc === 4) { + this[NEXT] = tree.preceding(value, {root: root}); + } + else /* if (iterateFunc === 5)*/ { + this[NEXT] = tree.following(value, {root: root}); + } + + return { + done: false, + value: value, + }; + } +} + +Object.defineProperty(TreeIterator.prototype, Symbol.iterator, { + value: function() { + return this; + }, + writable: false, +}); + +TreeIterator.PREV = 1; +TreeIterator.NEXT = 2; +TreeIterator.PARENT = 3; +TreeIterator.PRECEDING = 4; +TreeIterator.FOLLOWING = 5; + +Object.freeze(TreeIterator); +Object.freeze(TreeIterator.prototype); + +module.exports = TreeIterator; Index: frontend/node_modules/symbol-tree/lib/TreePosition.js =================================================================== --- frontend/node_modules/symbol-tree/lib/TreePosition.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/symbol-tree/lib/TreePosition.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,11 @@ +'use strict'; + +/* eslint-disable sort-keys */ +module.exports = Object.freeze({ + // same as DOM DOCUMENT_POSITION_ + DISCONNECTED: 1, + PRECEDING: 2, + FOLLOWING: 4, + CONTAINS: 8, + CONTAINED_BY: 16, +});