metaapi.cloud-sdk
Version:
SDK for MetaApi, a professional cloud forex API which includes MetaTrader REST API and MetaTrader websocket API. Supports both MetaTrader 5 (MT5) and MetaTrader 4 (MT4). CopyFactory copy trading API included. (https://metaapi.cloud)
513 lines (512 loc) • 54 kB
JavaScript
/* eslint-disable @typescript-eslint/no-this-alias */ /**
* Simple binary search tree
*/ "use strict";
const customUtils = require("./customUtils");
/**
* Constructor
* @param {Object} options Optional
* @param {Boolean} options.unique Whether to enforce a 'unique' constraint on the key or not
* @param {Key} options.key Initialize this BST's key with key
* @param {Value} options.value Initialize this BST's data with [value]
* @param {Function} options.compareKeys Initialize this BST's compareKeys
*/ function BinarySearchTree(options) {
options = options || {};
this.left = null;
this.right = null;
this.parent = options.parent !== undefined ? options.parent : null;
if (Object.prototype.hasOwnProperty.call(options, "key")) {
this.key = options.key;
}
this.data = Object.prototype.hasOwnProperty.call(options, "value") ? [
options.value
] : [];
this.unique = options.unique || false;
this.compareKeys = options.compareKeys || customUtils.defaultCompareKeysFunction;
this.checkValueEquality = options.checkValueEquality || customUtils.defaultCheckValueEquality;
}
// ================================
// Methods used to test the tree
// ================================
/**
* Get the descendant with max key
*/ BinarySearchTree.prototype.getMaxKeyDescendant = function() {
if (this.right) {
return this.right.getMaxKeyDescendant();
} else {
return this;
}
};
/**
* Get the maximum key
*/ BinarySearchTree.prototype.getMaxKey = function() {
return this.getMaxKeyDescendant().key;
};
/**
* Get the descendant with min key
*/ BinarySearchTree.prototype.getMinKeyDescendant = function() {
if (this.left) {
return this.left.getMinKeyDescendant();
} else {
return this;
}
};
/**
* Get the minimum key
*/ BinarySearchTree.prototype.getMinKey = function() {
return this.getMinKeyDescendant().key;
};
/**
* Check that all nodes (incl. leaves) fullfil condition given by fn
* test is a function passed every (key, data) and which throws if the condition is not met
*/ BinarySearchTree.prototype.checkAllNodesFullfillCondition = function(test) {
if (!Object.prototype.hasOwnProperty.call(this, "key")) {
return;
}
test(this.key, this.data);
if (this.left) {
this.left.checkAllNodesFullfillCondition(test);
}
if (this.right) {
this.right.checkAllNodesFullfillCondition(test);
}
};
/**
* Check that the core BST properties on node ordering are verified
* Throw if they aren't
*/ BinarySearchTree.prototype.checkNodeOrdering = function() {
let self = this;
if (!Object.prototype.hasOwnProperty.call(this, "key")) {
return;
}
if (this.left) {
this.left.checkAllNodesFullfillCondition(function(k) {
if (self.compareKeys(k, self.key) >= 0) {
throw new Error("Tree with root " + self.key + " is not a binary search tree");
}
});
this.left.checkNodeOrdering();
}
if (this.right) {
this.right.checkAllNodesFullfillCondition(function(k) {
if (self.compareKeys(k, self.key) <= 0) {
throw new Error("Tree with root " + self.key + " is not a binary search tree");
}
});
this.right.checkNodeOrdering();
}
};
/**
* Check that all pointers are coherent in this tree
*/ BinarySearchTree.prototype.checkInternalPointers = function() {
if (this.left) {
if (this.left.parent !== this) {
throw new Error("Parent pointer broken for key " + this.key);
}
this.left.checkInternalPointers();
}
if (this.right) {
if (this.right.parent !== this) {
throw new Error("Parent pointer broken for key " + this.key);
}
this.right.checkInternalPointers();
}
};
/**
* Check that a tree is a BST as defined here (node ordering and pointer references)
*/ BinarySearchTree.prototype.checkIsBST = function() {
this.checkNodeOrdering();
this.checkInternalPointers();
if (this.parent) {
throw new Error("The root shouldn't have a parent");
}
};
/**
* Get number of keys inserted
*/ BinarySearchTree.prototype.getNumberOfKeys = function() {
let res;
if (!Object.prototype.hasOwnProperty.call(this, "key")) {
return 0;
}
res = 1;
if (this.left) {
res += this.left.getNumberOfKeys();
}
if (this.right) {
res += this.right.getNumberOfKeys();
}
return res;
};
// ============================================
// Methods used to actually work on the tree
// ============================================
/**
* Create a BST similar (i.e. same options except for key and value) to the current one
* Use the same constructor (i.e. BinarySearchTree, AVLTree etc)
* @param {Object} options see constructor
*/ BinarySearchTree.prototype.createSimilar = function(options) {
options = options || {};
options.unique = this.unique;
options.compareKeys = this.compareKeys;
options.checkValueEquality = this.checkValueEquality;
return new this.constructor(options);
};
/**
* Create the left child of this BST and return it
*/ BinarySearchTree.prototype.createLeftChild = function(options) {
let leftChild = this.createSimilar(options);
leftChild.parent = this;
this.left = leftChild;
return leftChild;
};
/**
* Create the right child of this BST and return it
*/ BinarySearchTree.prototype.createRightChild = function(options) {
let rightChild = this.createSimilar(options);
rightChild.parent = this;
this.right = rightChild;
return rightChild;
};
/**
* Insert a new element
*/ BinarySearchTree.prototype.insert = function(key, value) {
// Empty tree, insert as root
if (!Object.prototype.hasOwnProperty.call(this, "key")) {
this.key = key;
this.data.push(value);
return;
}
// Same key as root
if (this.compareKeys(this.key, key) === 0) {
if (this.unique) {
let err = new Error("Can't insert key " + key + ", it violates the unique constraint");
err.key = key;
err.errorType = "uniqueViolated";
throw err;
} else {
this.data.push(value);
}
return;
}
if (this.compareKeys(key, this.key) < 0) {
// Insert in left subtree
if (this.left) {
this.left.insert(key, value);
} else {
this.createLeftChild({
key: key,
value: value
});
}
} else {
// Insert in right subtree
if (this.right) {
this.right.insert(key, value);
} else {
this.createRightChild({
key: key,
value: value
});
}
}
};
/**
* Search for all data corresponding to a key
*/ BinarySearchTree.prototype.search = function(key) {
if (!Object.prototype.hasOwnProperty.call(this, "key")) {
return [];
}
if (this.compareKeys(this.key, key) === 0) {
return this.data;
}
if (this.compareKeys(key, this.key) < 0) {
if (this.left) {
return this.left.search(key);
} else {
return [];
}
} else {
if (this.right) {
return this.right.search(key);
} else {
return [];
}
}
};
/**
* Return a function that tells whether a given key matches a lower bound
*/ BinarySearchTree.prototype.getLowerBoundMatcher = function(query) {
let self = this;
// No lower bound
if (!Object.prototype.hasOwnProperty.call(query, "$gt") && !Object.prototype.hasOwnProperty.call(query, "$gte")) {
return function() {
return true;
};
}
if (Object.prototype.hasOwnProperty.call(query, "$gt") && Object.prototype.hasOwnProperty.call(query, "$gte")) {
if (self.compareKeys(query.$gte, query.$gt) === 0) {
return function(key) {
return self.compareKeys(key, query.$gt) > 0;
};
}
if (self.compareKeys(query.$gte, query.$gt) > 0) {
return function(key) {
return self.compareKeys(key, query.$gte) >= 0;
};
} else {
return function(key) {
return self.compareKeys(key, query.$gt) > 0;
};
}
}
if (Object.prototype.hasOwnProperty.call(query, "$gt")) {
return function(key) {
return self.compareKeys(key, query.$gt) > 0;
};
} else {
return function(key) {
return self.compareKeys(key, query.$gte) >= 0;
};
}
};
/**
* Return a function that tells whether a given key matches an upper bound
*/ BinarySearchTree.prototype.getUpperBoundMatcher = function(query) {
let self = this;
// No lower bound
if (!Object.prototype.hasOwnProperty.call(query, "$lt") && !Object.prototype.hasOwnProperty.call(query, "$lte")) {
return function() {
return true;
};
}
if (Object.prototype.hasOwnProperty.call(query, "$lt") && Object.prototype.hasOwnProperty.call(query, "$lte")) {
if (self.compareKeys(query.$lte, query.$lt) === 0) {
return function(key) {
return self.compareKeys(key, query.$lt) < 0;
};
}
if (self.compareKeys(query.$lte, query.$lt) < 0) {
return function(key) {
return self.compareKeys(key, query.$lte) <= 0;
};
} else {
return function(key) {
return self.compareKeys(key, query.$lt) < 0;
};
}
}
if (Object.prototype.hasOwnProperty.call(query, "$lt")) {
return function(key) {
return self.compareKeys(key, query.$lt) < 0;
};
} else {
return function(key) {
return self.compareKeys(key, query.$lte) <= 0;
};
}
};
// Append all elements in toAppend to array
function append(array, toAppend) {
let i;
for(i = 0; i < toAppend.length; i += 1){
array.push(toAppend[i]);
}
}
/**
* Get all data for a key between bounds
* Return it in key order
* @param {Object} query Mongo-style query where keys are $lt, $lte, $gt or $gte (other keys are not considered)
* @param {Functions} lbm/ubm matching functions calculated at the first recursive step
*/ // eslint-disable-next-line complexity
BinarySearchTree.prototype.betweenBounds = function(query, lbm, ubm) {
let res = [];
if (!Object.prototype.hasOwnProperty.call(this, "key")) {
return [];
} // Empty tree
lbm = lbm || this.getLowerBoundMatcher(query);
ubm = ubm || this.getUpperBoundMatcher(query);
if (lbm(this.key) && this.left) {
append(res, this.left.betweenBounds(query, lbm, ubm));
}
if (lbm(this.key) && ubm(this.key)) {
append(res, this.data);
}
if (ubm(this.key) && this.right) {
append(res, this.right.betweenBounds(query, lbm, ubm));
}
return res;
};
/**
* Delete the current node if it is a leaf
* Return true if it was deleted
*/ BinarySearchTree.prototype.deleteIfLeaf = function() {
if (this.left || this.right) {
return false;
}
// The leaf is itself a root
if (!this.parent) {
delete this.key;
this.data = [];
return true;
}
if (this.parent.left === this) {
this.parent.left = null;
} else {
this.parent.right = null;
}
return true;
};
/**
* Delete the current node if it has only one child
* Return true if it was deleted
*/ // eslint-disable-next-line complexity
BinarySearchTree.prototype.deleteIfOnlyOneChild = function() {
let child;
if (this.left && !this.right) {
child = this.left;
}
if (!this.left && this.right) {
child = this.right;
}
if (!child) {
return false;
}
// Root
if (!this.parent) {
this.key = child.key;
this.data = child.data;
this.left = null;
if (child.left) {
this.left = child.left;
child.left.parent = this;
}
this.right = null;
if (child.right) {
this.right = child.right;
child.right.parent = this;
}
return true;
}
if (this.parent.left === this) {
this.parent.left = child;
child.parent = this.parent;
} else {
this.parent.right = child;
child.parent = this.parent;
}
return true;
};
/**
* Delete a key or just a value
* @param {Key} key
* @param {Value} value Optional. If not set, the whole key is deleted. If set, only this value is deleted
*/ // eslint-disable-next-line max-statements, complexity
BinarySearchTree.prototype.delete = function(key, value) {
let newData = [], replaceWith, self = this;
if (!Object.prototype.hasOwnProperty.call(this, "key")) {
return;
}
if (this.compareKeys(key, this.key) < 0) {
if (this.left) {
this.left.delete(key, value);
}
return;
}
if (this.compareKeys(key, this.key) > 0) {
if (this.right) {
this.right.delete(key, value);
}
return;
}
if (!this.compareKeys(key, this.key) === 0) {
return;
}
// Delete only a value
if (this.data.length > 1 && value !== undefined) {
this.data.forEach(function(d) {
if (!self.checkValueEquality(d, value)) {
newData.push(d);
}
});
self.data = newData;
return;
}
// Delete the whole node
if (this.deleteIfLeaf()) {
return;
}
if (this.deleteIfOnlyOneChild()) {
return;
}
// We are in the case where the node to delete has two children
if (Math.random() >= 0.5) {
// Use the in-order predecessor
replaceWith = this.left.getMaxKeyDescendant();
this.key = replaceWith.key;
this.data = replaceWith.data;
if (this === replaceWith.parent) {
this.left = replaceWith.left;
if (replaceWith.left) {
replaceWith.left.parent = replaceWith.parent;
}
} else {
replaceWith.parent.right = replaceWith.left;
if (replaceWith.left) {
replaceWith.left.parent = replaceWith.parent;
}
}
} else {
// Use the in-order successor
replaceWith = this.right.getMinKeyDescendant();
this.key = replaceWith.key;
this.data = replaceWith.data;
if (this === replaceWith.parent) {
this.right = replaceWith.right;
if (replaceWith.right) {
replaceWith.right.parent = replaceWith.parent;
}
} else {
replaceWith.parent.left = replaceWith.right;
if (replaceWith.right) {
replaceWith.right.parent = replaceWith.parent;
}
}
}
};
/**
* Execute a function on every node of the tree, in key order
* @param {Function} fn Signature: node. Most useful will probably be node.key and node.data
*/ BinarySearchTree.prototype.executeOnEveryNode = function(fn) {
if (this.left) {
this.left.executeOnEveryNode(fn);
}
fn(this);
if (this.right) {
this.right.executeOnEveryNode(fn);
}
};
/**
* Pretty print a tree
* @param {Boolean} printData To print the nodes' data along with the key
*/ BinarySearchTree.prototype.prettyPrint = function(printData, spacing) {
spacing = spacing || "";
console.log(spacing + "* " + this.key);
if (printData) {
console.log(spacing + "* " + this.data);
}
if (!this.left && !this.right) {
return;
}
if (this.left) {
this.left.prettyPrint(printData, spacing + " ");
} else {
console.log(spacing + " *");
}
if (this.right) {
this.right.prettyPrint(printData, spacing + " ");
} else {
console.log(spacing + " *");
}
};
// Interface
module.exports = BinarySearchTree;
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-this-alias */\n/**\n * Simple binary search tree\n */\nconst customUtils = require('./customUtils');\n\n\n/**\n * Constructor\n * @param {Object} options Optional\n * @param {Boolean}  options.unique Whether to enforce a 'unique' constraint on the key or not\n * @param {Key}      options.key Initialize this BST's key with key\n * @param {Value}    options.value Initialize this BST's data with [value]\n * @param {Function} options.compareKeys Initialize this BST's compareKeys\n */\nfunction BinarySearchTree (options) {\n  options = options || {};\n\n  this.left = null;\n  this.right = null;\n  this.parent = options.parent !== undefined ? options.parent : null;\n  if (Object.prototype.hasOwnProperty.call(options, 'key')) { this.key = options.key; }\n  this.data = Object.prototype.hasOwnProperty.call(options, 'value') ? [options.value] : [];\n  this.unique = options.unique || false;\n\n  this.compareKeys = options.compareKeys || customUtils.defaultCompareKeysFunction;\n  this.checkValueEquality = options.checkValueEquality || customUtils.defaultCheckValueEquality;\n}\n\n\n// ================================\n// Methods used to test the tree\n// ================================\n\n\n/**\n * Get the descendant with max key\n */\nBinarySearchTree.prototype.getMaxKeyDescendant = function () {\n  if (this.right) {\n    return this.right.getMaxKeyDescendant();\n  } else {\n    return this;\n  }\n};\n\n\n/**\n * Get the maximum key\n */\nBinarySearchTree.prototype.getMaxKey = function () {\n  return this.getMaxKeyDescendant().key;\n};\n\n\n/**\n * Get the descendant with min key\n */\nBinarySearchTree.prototype.getMinKeyDescendant = function () {\n  if (this.left) {\n    return this.left.getMinKeyDescendant()\n  } else {\n    return this;\n  }\n};\n\n\n/**\n * Get the minimum key\n */\nBinarySearchTree.prototype.getMinKey = function () {\n  return this.getMinKeyDescendant().key;\n};\n\n\n/**\n * Check that all nodes (incl. leaves) fullfil condition given by fn\n * test is a function passed every (key, data) and which throws if the condition is not met\n */\nBinarySearchTree.prototype.checkAllNodesFullfillCondition = function (test) {\n  if (!Object.prototype.hasOwnProperty.call(this, 'key')) { return; }\n\n  test(this.key, this.data);\n  if (this.left) { this.left.checkAllNodesFullfillCondition(test); }\n  if (this.right) { this.right.checkAllNodesFullfillCondition(test); }\n};\n\n\n/**\n * Check that the core BST properties on node ordering are verified\n * Throw if they aren't\n */\nBinarySearchTree.prototype.checkNodeOrdering = function () {\n  let self = this;\n\n  if (!Object.prototype.hasOwnProperty.call(this, 'key')) { return; }\n\n  if (this.left) {\n    this.left.checkAllNodesFullfillCondition(function (k) {\n      if (self.compareKeys(k, self.key) >= 0) {\n        throw new Error('Tree with root ' + self.key + ' is not a binary search tree');\n      }\n    });\n    this.left.checkNodeOrdering();\n  }\n\n  if (this.right) {\n    this.right.checkAllNodesFullfillCondition(function (k) {\n      if (self.compareKeys(k, self.key) <= 0) {\n        throw new Error('Tree with root ' + self.key + ' is not a binary search tree');\n      }\n    });\n    this.right.checkNodeOrdering();\n  }\n};\n\n\n/**\n * Check that all pointers are coherent in this tree\n */\nBinarySearchTree.prototype.checkInternalPointers = function () {\n  if (this.left) {\n    if (this.left.parent !== this) { throw new Error('Parent pointer broken for key ' + this.key); }\n    this.left.checkInternalPointers();\n  }\n\n  if (this.right) {\n    if (this.right.parent !== this) { throw new Error('Parent pointer broken for key ' + this.key); }\n    this.right.checkInternalPointers();\n  }\n};\n\n\n/**\n * Check that a tree is a BST as defined here (node ordering and pointer references)\n */\nBinarySearchTree.prototype.checkIsBST = function () {\n  this.checkNodeOrdering();\n  this.checkInternalPointers();\n  if (this.parent) { throw new Error('The root shouldn\\'t have a parent'); }\n};\n\n\n/**\n * Get number of keys inserted\n */\nBinarySearchTree.prototype.getNumberOfKeys = function () {\n  let res;\n\n  if (!Object.prototype.hasOwnProperty.call(this, 'key')) { return 0; }\n\n\n  res = 1;\n  if (this.left) { res += this.left.getNumberOfKeys(); }\n  if (this.right) { res += this.right.getNumberOfKeys(); }\n\n  return res;\n};\n\n\n\n// ============================================\n// Methods used to actually work on the tree\n// ============================================\n\n/**\n * Create a BST similar (i.e. same options except for key and value) to the current one\n * Use the same constructor (i.e. BinarySearchTree, AVLTree etc)\n * @param {Object} options see constructor\n */\nBinarySearchTree.prototype.createSimilar = function (options) {\n  options = options || {};\n  options.unique = this.unique;\n  options.compareKeys = this.compareKeys;\n  options.checkValueEquality = this.checkValueEquality;\n\n  return new this.constructor(options);\n};\n\n\n/**\n * Create the left child of this BST and return it\n */\nBinarySearchTree.prototype.createLeftChild = function (options) {\n  let leftChild = this.createSimilar(options);\n  leftChild.parent = this;\n  this.left = leftChild;\n\n  return leftChild;\n};\n\n\n/**\n * Create the right child of this BST and return it\n */\nBinarySearchTree.prototype.createRightChild = function (options) {\n  let rightChild = this.createSimilar(options);\n  rightChild.parent = this;\n  this.right = rightChild;\n\n  return rightChild;\n};\n\n\n/**\n * Insert a new element\n */\nBinarySearchTree.prototype.insert = function (key, value) {\n  // Empty tree, insert as root\n  if (!Object.prototype.hasOwnProperty.call(this, 'key')) {\n    this.key = key;\n    this.data.push(value);\n    return;\n  }\n\n  // Same key as root\n  if (this.compareKeys(this.key, key) === 0) {\n    if (this.unique) {\n      let err = new Error('Can\\'t insert key ' + key + ', it violates the unique constraint');\n      err.key = key;\n      err.errorType = 'uniqueViolated';\n      throw err;\n    } else {\n      this.data.push(value);\n    }\n    return;\n  }\n\n  if (this.compareKeys(key, this.key) < 0) {\n    // Insert in left subtree\n    if (this.left) {\n      this.left.insert(key, value);\n    } else {\n      this.createLeftChild({ key: key, value: value });\n    }\n  } else {\n    // Insert in right subtree\n    if (this.right) {\n      this.right.insert(key, value);\n    } else {\n      this.createRightChild({ key: key, value: value });\n    }\n  }\n};\n\n\n/**\n * Search for all data corresponding to a key\n */\nBinarySearchTree.prototype.search = function (key) {\n  if (!Object.prototype.hasOwnProperty.call(this, 'key')) { return []; }\n\n  if (this.compareKeys(this.key, key) === 0) { return this.data; }\n\n  if (this.compareKeys(key, this.key) < 0) {\n    if (this.left) {\n      return this.left.search(key);\n    } else {\n      return [];\n    }\n  } else {\n    if (this.right) {\n      return this.right.search(key);\n    } else {\n      return [];\n    }\n  }\n};\n\n\n/**\n * Return a function that tells whether a given key matches a lower bound\n */\nBinarySearchTree.prototype.getLowerBoundMatcher = function (query) {\n  let self = this;\n\n  // No lower bound\n  if (!Object.prototype.hasOwnProperty.call(query, '$gt') && !Object.prototype.hasOwnProperty.call(query, '$gte')) {\n    return function () { return true; };\n  }\n\n  if (Object.prototype.hasOwnProperty.call(query, '$gt') && Object.prototype.hasOwnProperty.call(query, '$gte')) {\n    if (self.compareKeys(query.$gte, query.$gt) === 0) {\n      return function (key) { return self.compareKeys(key, query.$gt) > 0; };\n    }\n\n    if (self.compareKeys(query.$gte, query.$gt) > 0) {\n      return function (key) { return self.compareKeys(key, query.$gte) >= 0; };\n    } else {\n      return function (key) { return self.compareKeys(key, query.$gt) > 0; };\n    }\n  }\n\n  if (Object.prototype.hasOwnProperty.call(query, '$gt')) {\n    return function (key) { return self.compareKeys(key, query.$gt) > 0; };\n  } else {\n    return function (key) { return self.compareKeys(key, query.$gte) >= 0; };\n  }\n};\n\n\n/**\n * Return a function that tells whether a given key matches an upper bound\n */\nBinarySearchTree.prototype.getUpperBoundMatcher = function (query) {\n  let self = this;\n\n  // No lower bound\n  if (!Object.prototype.hasOwnProperty.call(query, '$lt') && !Object.prototype.hasOwnProperty.call(query, '$lte')) {\n    return function () { return true; };\n  }\n\n  if (Object.prototype.hasOwnProperty.call(query, '$lt') && Object.prototype.hasOwnProperty.call(query, '$lte')) {\n    if (self.compareKeys(query.$lte, query.$lt) === 0) {\n      return function (key) { return self.compareKeys(key, query.$lt) < 0; };\n    }\n\n    if (self.compareKeys(query.$lte, query.$lt) < 0) {\n      return function (key) { return self.compareKeys(key, query.$lte) <= 0; };\n    } else {\n      return function (key) { return self.compareKeys(key, query.$lt) < 0; };\n    }\n  }\n\n  if (Object.prototype.hasOwnProperty.call(query, '$lt')) {\n    return function (key) { return self.compareKeys(key, query.$lt) < 0; };\n  } else {\n    return function (key) { return self.compareKeys(key, query.$lte) <= 0; };\n  }\n};\n\n\n// Append all elements in toAppend to array\nfunction append (array, toAppend) {\n  let i;\n\n  for (i = 0; i < toAppend.length; i += 1) {\n    array.push(toAppend[i]);\n  }\n}\n\n\n/**\n * Get all data for a key between bounds\n * Return it in key order\n * @param {Object} query Mongo-style query where keys are $lt, $lte, $gt or $gte (other keys are not considered)\n * @param {Functions} lbm/ubm matching functions calculated at the first recursive step\n */\n// eslint-disable-next-line complexity\nBinarySearchTree.prototype.betweenBounds = function (query, lbm, ubm) {\n  let res = [];\n\n  if (!Object.prototype.hasOwnProperty.call(this, 'key')) { return []; }   // Empty tree\n\n  lbm = lbm || this.getLowerBoundMatcher(query);\n  ubm = ubm || this.getUpperBoundMatcher(query);\n\n  if (lbm(this.key) && this.left) { append(res, this.left.betweenBounds(query, lbm, ubm)); }\n  if (lbm(this.key) && ubm(this.key)) { append(res, this.data); }\n  if (ubm(this.key) && this.right) { append(res, this.right.betweenBounds(query, lbm, ubm)); }\n\n  return res;\n};\n\n\n/**\n * Delete the current node if it is a leaf\n * Return true if it was deleted\n */\nBinarySearchTree.prototype.deleteIfLeaf = function () {\n  if (this.left || this.right) { return false; }\n\n  // The leaf is itself a root\n  if (!this.parent) {\n    delete this.key;\n    this.data = [];\n    return true;\n  }\n\n  if (this.parent.left === this) {\n    this.parent.left = null;\n  } else {\n    this.parent.right = null;\n  }\n\n  return true;\n};\n\n\n/**\n * Delete the current node if it has only one child\n * Return true if it was deleted\n */\n// eslint-disable-next-line complexity\nBinarySearchTree.prototype.deleteIfOnlyOneChild = function () {\n  let child;\n\n  if (this.left && !this.right) { child = this.left; }\n  if (!this.left && this.right) { child = this.right; }\n  if (!child) { return false; }\n\n  // Root\n  if (!this.parent) {\n    this.key = child.key;\n    this.data = child.data;\n\n    this.left = null;\n    if (child.left) {\n      this.left = child.left;\n      child.left.parent = this;\n    }\n\n    this.right = null;\n    if (child.right) {\n      this.right = child.right;\n      child.right.parent = this;\n    }\n\n    return true;\n  }\n\n  if (this.parent.left === this) {\n    this.parent.left = child;\n    child.parent = this.parent;\n  } else {\n    this.parent.right = child;\n    child.parent = this.parent;\n  }\n\n  return true;\n};\n\n\n/**\n * Delete a key or just a value\n * @param {Key} key\n * @param {Value} value Optional. If not set, the whole key is deleted. If set, only this value is deleted\n */\n// eslint-disable-next-line max-statements, complexity\nBinarySearchTree.prototype.delete = function (key, value) {\n  let newData = [], replaceWith\n    , self = this\n    ;\n\n  if (!Object.prototype.hasOwnProperty.call(this, 'key')) { return; }\n\n  if (this.compareKeys(key, this.key) < 0) {\n    if (this.left) { this.left.delete(key, value); }\n    return;\n  }\n\n  if (this.compareKeys(key, this.key) > 0) {\n    if (this.right) { this.right.delete(key, value); }\n    return;\n  }\n\n  if (!this.compareKeys(key, this.key) === 0) { return; }\n\n  // Delete only a value\n  if (this.data.length > 1 && value !== undefined) {\n    this.data.forEach(function (d) {\n      if (!self.checkValueEquality(d, value)) { newData.push(d); }\n    });\n    self.data = newData;\n    return;\n  }\n\n  // Delete the whole node\n  if (this.deleteIfLeaf()) {\n    return;\n  }\n  if (this.deleteIfOnlyOneChild()) {\n    return;\n  }\n\n  // We are in the case where the node to delete has two children\n  if (Math.random() >= 0.5) {   // Randomize replacement to avoid unbalancing the tree too much\n    // Use the in-order predecessor\n    replaceWith = this.left.getMaxKeyDescendant();\n\n    this.key = replaceWith.key;\n    this.data = replaceWith.data;\n\n    if (this === replaceWith.parent) {   // Special case\n      this.left = replaceWith.left;\n      if (replaceWith.left) { replaceWith.left.parent = replaceWith.parent; }\n    } else {\n      replaceWith.parent.right = replaceWith.left;\n      if (replaceWith.left) { replaceWith.left.parent = replaceWith.parent; }\n    }\n  } else {\n    // Use the in-order successor\n    replaceWith = this.right.getMinKeyDescendant();\n\n    this.key = replaceWith.key;\n    this.data = replaceWith.data;\n\n    if (this === replaceWith.parent) {   // Special case\n      this.right = replaceWith.right;\n      if (replaceWith.right) { replaceWith.right.parent = replaceWith.parent; }\n    } else {\n      replaceWith.parent.left = replaceWith.right;\n      if (replaceWith.right) { replaceWith.right.parent = replaceWith.parent; }\n    }\n  }\n};\n\n\n/**\n * Execute a function on every node of the tree, in key order\n * @param {Function} fn Signature: node. Most useful will probably be node.key and node.data\n */\nBinarySearchTree.prototype.executeOnEveryNode = function (fn) {\n  if (this.left) { this.left.executeOnEveryNode(fn); }\n  fn(this);\n  if (this.right) { this.right.executeOnEveryNode(fn); }\n};\n\n\n/**\n * Pretty print a tree\n * @param {Boolean} printData To print the nodes' data along with the key\n */\nBinarySearchTree.prototype.prettyPrint = function (printData, spacing) {\n  spacing = spacing || '';\n\n  console.log(spacing + '* ' + this.key);\n  if (printData) { console.log(spacing + '* ' + this.data); }\n\n  if (!this.left && !this.right) { return; }\n\n  if (this.left) {\n    this.left.prettyPrint(printData, spacing + '  ');\n  } else {\n    console.log(spacing + '  *');\n  }\n  if (this.right) {\n    this.right.prettyPrint(printData, spacing + '  ');\n  } else {\n    console.log(spacing + '  *');\n  }\n};\n\n\n// Interface\nmodule.exports = BinarySearchTree;\n"],"names":["customUtils","require","BinarySearchTree","options","left","right","parent","undefined","Object","prototype","hasOwnProperty","call","key","data","value","unique","compareKeys","defaultCompareKeysFunction","checkValueEquality","defaultCheckValueEquality","getMaxKeyDescendant","getMaxKey","getMinKeyDescendant","getMinKey","checkAllNodesFullfillCondition","test","checkNodeOrdering","self","k","Error","checkInternalPointers","checkIsBST","getNumberOfKeys","res","createSimilar","constructor","createLeftChild","leftChild","createRightChild","rightChild","insert","push","err","errorType","search","getLowerBoundMatcher","query","$gte","$gt","getUpperBoundMatcher","$lte","$lt","append","array","toAppend","i","length","betweenBounds","lbm","ubm","deleteIfLeaf","deleteIfOnlyOneChild","child","delete","newData","replaceWith","forEach","d","Math","random","executeOnEveryNode","fn","prettyPrint","printData","spacing","console","log","module","exports"],"mappings":"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