{"version":3,"sources":["webpack://sangja/webpack/universalModuleDefinition","webpack://sangja/webpack/bootstrap","webpack://sangja/./src/utils.js","webpack://sangja/./src/queue.js","webpack://sangja/./src/linked-list.js","webpack://sangja/./src/index.js","webpack://sangja/./src/optional.js","webpack://sangja/./src/stack.js","webpack://sangja/./src/heap.js","webpack://sangja/./src/binary-search-tree.js"],"names":["root","factory","exports","module","define","amd","this","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","isIterable","obj","iterator","defaultKey","x","defaultCompare","y","mergeOptions","given","original","merged","keys","forEach","Utils","LinkedList","Queue","[object Object]","iterable","TypeError","_linkedList","addLast","v","size","popFirst","getFirst","isEmpty","f","queue","map","flatMap","filter","reversed","some","every","includes","front","end","index","now","next","prev","undefined","RangeError","item","_getNode","addAllLast","values","length","add","popLast","pop","result","remove","push","removeMatch","ret","list","addFirst","Optional","Stack","Heap","BinarySearchTree","err","Boolean","_stack","stack","arr","pushAll","a","b","compare","reverse","_heap","_options","_key","_compare","Math","floor","tmp","left","right","heapForIter","slice","options","heap","addAll","that","_root","children","parent","direction","comp","rightmostParent","rightmost","removeVal","_getMatch","node","nodes","_forEach","tree","constructor","_some","_every","inorder","_inorderIterator","_inorder","_preorderIterator","_preorder","_postorderIterator","_postorder","enqueue","dequeue","_breadthFirst"],"mappings":"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","file":"sangja.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"sangja\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"sangja\"] = factory();\n\telse\n\t\troot[\"sangja\"] = factory();\n})(this, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 3);\n","/**\n * Check if given object is iterable\n * @function\n * @memberof sangja\n * @param {*} obj - An object to check if iterable\n * @return {boolean} True if obj is iterable else false\n */\nfunction isIterable(obj) {\n  // checks for null and undefined\n  if (obj == null) {\n    return false;\n  }\n  return typeof obj[Symbol.iterator] === 'function';\n}\n\n/**\n * Default key function.<br>\n * Data structures that require compare will use this function as a default key function.<br>\n * Returns the input argument as it is.\n * @function\n * @memberof sangja\n */\nconst defaultKey = x => x;\n\n/**\n * Default compare function.<br>\n * Data structures that require compare will use this function as a default compare function.<br>\n * Compare 2 given operands and return the result. This function can compare number, string.\n * @function\n * @memberof sangja\n */\nconst defaultCompare = (x, y) => {\n  if (x < y) {\n    return -1;\n  }\n  if (x > y) {\n    return 1;\n  }\n  return 0;\n};\n\nfunction mergeOptions(given = {}, original = {}) {\n  if (!given) {\n    return original;\n  }\n\n  const merged = {};\n  Object.keys(original).forEach((key) => {\n    merged[key] = given[key] || original[key];\n  });\n  return merged;\n}\n\nmodule.exports = {\n  isIterable,\n  defaultKey,\n  defaultCompare,\n  mergeOptions,\n};\n","const Utils = require('./utils');\nconst LinkedList = require('./linked-list');\n\n/**\n * @class\n * @memberof sangja\n */\nclass Queue {\n  /**\n   * Creates a new Queue.\n   * Iterable parameter is optional.\n   * @constructor\n   * @param {iterable} [iterable] - Iterator for initialize the queue.\n   * @throws {TypeError} When given parameter is not queue.\n   */\n  constructor(iterable = []) {\n    if (!Utils.isIterable(iterable)) {\n      throw TypeError();\n    }\n    this._linkedList = new LinkedList(iterable);\n  }\n\n  /**\n   * Add value at the rear of the queue.\n   * @param {*} value - The value to enqueue to the queue.\n   */\n  enqueue(value) {\n    this._linkedList.addLast(value);\n  }\n\n  /**\n   * Add values in the given iterator at the rear of the queue.\n   * @param {iterable} iterable - The iterable values to enqueue\n   */\n  enqueueAll(iterable) {\n    [...iterable].forEach(v => this._linkedList.addLast(v));\n  }\n\n  /**\n   * Removes the front of the queue and returns the value at the front of the queue.\n   * @returns {*} The value at the front of the queue. If empty, return undefined.\n   */\n  dequeue() {\n    if (this._linkedList.size() === 0) {\n      return undefined;\n    }\n\n    return this._linkedList.popFirst();\n  }\n\n  /**\n   * Returns the value at the front of the queue without changing the state of the queue.\n   * @returns {*} The value at the front of the queue. If empty, return undefined.\n   */\n  peek() {\n    if (this._linkedList.size() === 0) {\n      return undefined;\n    }\n\n    return this._linkedList.getFirst();\n  }\n\n  /**\n   * Returns the number of elements in the queue.\n   * @returns {number} The number of elements in the queue.\n   */\n  size() {\n    return this._linkedList.size();\n  }\n\n  /**\n   * Returns whether the queue is empty.\n   * @returns {boolean} True if the queue is empty.\n   */\n  isEmpty() {\n    return this._linkedList.isEmpty();\n  }\n\n  /**\n   * Removes all values in the queue.\n   */\n  clear() {\n    this._linkedList = new LinkedList();\n  }\n\n  /**\n   * For each values in the queue, execute the given procedure f.\n   * @param {function} f - Procedure to execute\n   */\n  forEach(f) {\n    this._linkedList.forEach(f);\n  }\n\n  /**\n   * Returns a new Queue whose values are mapped with given function f.\n   * @param {function} f - Function to map values\n   * @return {Stack} Queue([mapped values])\n   */\n  map(f) {\n    const queue = new Queue();\n    queue._linkedList = this._linkedList.map(f);\n    return queue;\n  }\n\n  /**\n   * Returns a new Queue whose values are mapped with given function f and flattened.\n   * @param {function} f - Function (this.value) => iterable\n   * @return {Stack} Queue([mapped and flattened values])\n   */\n  flatMap(f) {\n    const queue = new Queue();\n    queue._linkedList = this._linkedList.flatMap(f);\n    return queue;\n  }\n\n  /**\n   * Returns a new Queue whose values are filtered with given predicate f.\n   * @param {function} f - Predicate (this.value) => boolean\n   * @return {Stack} Queue([filtered values])\n   */\n  filter(f) {\n    const queue = new Queue();\n    queue._linkedList = this._linkedList.filter(f);\n    return queue;\n  }\n\n  /**\n   * Returns a new Queue whose values are reversed in order.\n   * @return {Stack} Queue([reversed values])\n   */\n  reversed() {\n    const queue = new Queue();\n    queue._linkedList = this._linkedList.reversed();\n    return queue;\n  }\n\n  /**\n   * If any of containing values satisfies given f, return true.\n   * If none of values satisfy f or not contain any value, return false.\n   * @param {function} f - Predicate\n   * @returns {boolean}\n   */\n  some(f) {\n    return this._linkedList.some(f);\n  }\n\n  /**\n   * If all of containing values satisfies given f or not contain any value, return true.\n   * If any of value doesn't satisfy f, return false.\n   * @param {function} f - Predicate\n   * @returns {boolean}\n   */\n  every(f) {\n    return this._linkedList.every(f);\n  }\n\n  /**\n   * If contains given value v, return true.\n   * @param {*} v\n   * @returns {boolean}\n   */\n  includes(v) {\n    return this._linkedList.includes(v);\n  }\n\n  * [Symbol.iterator]() {\n    yield* this._linkedList;\n  }\n}\n\nmodule.exports = Queue;\n","const Utils = require('./utils');\n\n/**\n * @class\n * @memberof sangja\n */\nclass LinkedList {\n  /**\n   * Creates a new LinkedList.\n   * Iterable parameter is optional.\n   * @constructor\n   * @param {iterable} [iterable] - Iterator for initialize the list.\n   * @throws {TypeError} When given parameter is not iterable.\n   */\n  constructor(iterable = []) {\n    this._linkedList = {\n      size: 0,\n      front: null,\n      end: null,\n    };\n    if (!Utils.isIterable(iterable)) {\n      throw TypeError();\n    }\n    [...iterable].forEach(v => this.addLast(v));\n  }\n\n  /**\n   * Return the node at the given index of the linked list.\n   * @param {number} index - The index to get node.\n   * @private\n   * @return {node} The node at the given index.\n   * When the given index < 0 or index >= size of the linked list, return undefined.\n   */\n  _getNode(index) {\n    if (typeof index !== 'number' || index < 0 || index >= this._linkedList.size) {\n      return undefined;\n    }\n    if (index < this._linkedList.size / 2) {\n      let now = this._linkedList.front;\n      for (let i = 0; i < index; i += 1) {\n        now = now.next;\n      }\n      return now;\n    }\n    let now = this._linkedList.end;\n    for (let i = this._linkedList.size - 1; i > index; i -= 1) {\n      now = now.prev;\n    }\n    return now;\n  }\n\n  /**\n   * Add value at the given index of the linked list.\n   * @param {number} [index] - The index to add the value.\n   * @param {*} value - The value to add.\n   * @throws {RangeError} When the given index < 0 or index > size of the linked list.\n   */\n  add(index, value) {\n    // Index not given. index is the value to add.\n    if (value === undefined) {\n      this.addLast(index);\n      return;\n    }\n    if (typeof index !== 'number' || index < 0 || index > this._linkedList.size) {\n      throw RangeError();\n    }\n\n    if (index === 0) {\n      const item = {\n        prev: null,\n        next: this._linkedList.front,\n        value,\n      };\n      if (this._linkedList.front) {\n        this._linkedList.front.prev = item;\n      } else {\n        // No elements until now.\n        this._linkedList.end = item;\n      }\n      this._linkedList.front = item;\n    } else if (index === this._linkedList.size) {\n      const item = {\n        prev: this._linkedList.end,\n        next: null,\n        value,\n      };\n      if (this._linkedList.end) {\n        this._linkedList.end.next = item;\n      }\n      this._linkedList.end = item;\n    } else {\n      const original = this._getNode(index);\n\n      const item = {\n        prev: original.prev,\n        next: original,\n        value,\n      };\n      item.prev.next = item;\n      item.next.prev = item;\n    }\n    this._linkedList.size += 1;\n  }\n\n  /**\n   * Add values in given iterator at the given index of the linked list.\n   * @param {number} [index] - The index to add the value.\n   * @param {iterable} iterable - The iterable object that contain values to add.\n   * @throws {RangeError} When the given index < 0 or index > size of the linked list.\n   */\n  addAll(index, iterable) {\n    // Index not given. index is iterable object.\n    if (iterable === undefined) {\n      this.addAllLast(index);\n      return;\n    }\n    const values = [...iterable];\n    for (let i = values.length - 1; i >= 0; i -= 1) {\n      this.add(index, values[i]);\n    }\n  }\n\n  /**\n   * Add value at the front of the linked list.\n   * @param {*} value - The value to add.\n   */\n  addFirst(value) {\n    this.add(0, value);\n  }\n\n  /**\n   * Add values in given iterator at the front of the linked list.\n   * @param {iterable} iterable - The iterable object that contain values to add.\n   */\n  addAllFirst(iterable) {\n    const values = [...iterable];\n    for (let i = values.length - 1; i >= 0; i -= 1) {\n      this.add(0, values[i]);\n    }\n  }\n\n  /**\n   * Add value at the end of the linked list.\n   * @param {*} value - The value to add.\n   */\n  addLast(value) {\n    this.add(this.size(), value);\n  }\n\n  /**\n   * Add values in given iterator at the end of the linked list.\n   * @param {iterable} iterable - The iterable object that contain values to add.\n   */\n  addAllLast(iterable) {\n    const values = [...iterable];\n    for (let i = 0; i < values.length; i += 1) {\n      this.addLast(values[i]);\n    }\n  }\n\n  /**\n   * Removes the given index of the linked list and\n   * returns the value at the given index of the linked list.\n   * @param {number} [index] - The index to remove the value.\n   * @return {*} The value at the given index of the linked list. If not found, return undefined.\n   */\n  pop(index) {\n    if (index === undefined) {\n      return this.popLast();\n    }\n    if (typeof index !== 'number' || index < 0 || index >= this._linkedList.size) {\n      return undefined;\n    }\n    const now = this._getNode(index);\n\n    if (now.prev) {\n      now.prev.next = now.next;\n    } else {\n      this._linkedList.front = now.next;\n    }\n\n    if (now.next) {\n      now.next.prev = now.prev;\n    } else {\n      this._linkedList.end = now.prev;\n    }\n\n    this._linkedList.size -= 1;\n    return now.value;\n  }\n\n  /**\n   * Removes the first of the linked list and\n   * returns the value at the first of the linked list.\n   * @return {*} The value at the front of the linked list. If empty, return undefined.\n   */\n  popFirst() {\n    return this.pop(0);\n  }\n\n  /**\n   * Removes the end of the linked list and\n   * returns the value at the end of the linked list.\n   * @return {*} The value at the end of the linked list. If empty, return undefined.\n   */\n  popLast() {\n    return this.pop(this.size() - 1);\n  }\n\n  /**\n   * Same with pop(i) except that index is required.\n   * @param {number} index - The index to remove the value.\n   * @return {(*|undefined)} The value at the given index of the linked list.\n   * If not found, return undefined.\n   */\n  removeAt(index) {\n    if (typeof index !== 'number' || index < 0 || index >= this._linkedList.size) {\n      return undefined;\n    }\n    return this.pop(index);\n  }\n\n  /**\n   * Removes the first occurance of the given value in the linked list and\n   * returns true if the given value is in the linked list.\n   * @param {*} value - The value to remove\n   * @return {boolean} True if the given value is in the linked list else false.\n   */\n  remove(value) {\n    let now = this._linkedList.front;\n    while (now) {\n      if (now.value === value) {\n        break;\n      }\n      now = now.next;\n    }\n\n    if (!now) {\n      return false;\n    }\n\n    if (now.prev) {\n      now.prev.next = now.next;\n    } else {\n      // now is front\n      this._linkedList.front = now.next;\n    }\n\n    if (now.next) {\n      now.next.prev = now.prev;\n    } else {\n      // now is end\n      this._linkedList.end = now.prev;\n    }\n\n    this._linkedList.size -= 1;\n    return true;\n  }\n\n  /**\n   * Removes the every occurance of the given value in the linked list and\n   * returns the number of removed values.\n   * @param {*} value - The value to remove\n   * @return {number} The number of removed values.\n   */\n  removeAll(value) {\n    let now = this._linkedList.front;\n    let result = 0;\n    while (now) {\n      if (now.value === value) {\n        if (now.prev) {\n          now.prev.next = now.next;\n        } else {\n          // now is front\n          this._linkedList.front = now.next;\n        }\n\n        if (now.next) {\n          now.next.prev = now.prev;\n        } else {\n          // now is end\n          this._linkedList.end = now.prev;\n        }\n\n        this._linkedList.size -= 1;\n        result += 1;\n      }\n      now = now.next;\n    }\n\n    return result;\n  }\n\n  /**\n   * Same with remove(value) if value is given.\n   * If value is not given, same with popFirst().\n   * @param {*} [value] - The value to remove\n   * @return {(*|undefined|boolean)} If remove success, return true.\n   * If value not given, return popFirst().\n   */\n  removeFirst(value) {\n    if (value === undefined) {\n      return this.popFirst();\n    }\n    return this.remove(value);\n  }\n\n  /**\n   * Same with remove(value) but find from start searching from last.\n   * @param {*} [value] - The value to remove\n   * @return {(*|undefined|boolean)} If remove success, return true.\n   * If value not given, return popLast().\n   */\n  removeLast(value) {\n    let now = this._linkedList.end;\n    while (now) {\n      if (now.value === value) {\n        break;\n      }\n      now = now.prev;\n    }\n\n    if (!now) {\n      return false;\n    }\n\n    if (now.prev) {\n      now.prev.next = now.next;\n    } else {\n      // now is front\n      this._linkedList.front = now.next;\n    }\n\n    if (now.next) {\n      now.next.prev = now.prev;\n    } else {\n      // now is end\n      this._linkedList.end = now.prev;\n    }\n\n    this._linkedList.size -= 1;\n    return true;\n  }\n\n  /**\n   * Removes the first value that matches given predicate f and\n   * returns value in the linked list.\n   * @param {Function} f - Predicate\n   * @return {(*|undefined)} Found value. If not found, return undefined.\n   * @throws {TypeError} When the given predicate is not a function.\n   */\n  removeMatch(f) {\n    if (typeof f !== 'function') {\n      throw TypeError();\n    }\n\n    let now = this._linkedList.front;\n    while (now) {\n      if (f(now.value)) {\n        break;\n      }\n      now = now.next;\n    }\n\n    if (!now) {\n      return undefined;\n    }\n\n    if (now.prev) {\n      now.prev.next = now.next;\n    } else {\n      // now is front\n      this._linkedList.front = now.next;\n    }\n\n    if (now.next) {\n      now.next.prev = now.prev;\n    } else {\n      // now is end\n      this._linkedList.end = now.prev;\n    }\n\n    this._linkedList.size -= 1;\n    return now.value;\n  }\n\n  /**\n   * Removes all values that matches given predicate f and\n   * returns the removed values.\n   * @param {Function} f - Predicate\n   * @return {any[]} Removed values.\n   * @throws {TypeError} When the given predicate is not a function.\n   */\n  removeMatchAll(f) {\n    if (typeof f !== 'function') {\n      throw TypeError();\n    }\n\n    let now = this._linkedList.front;\n    const result = [];\n    while (now) {\n      if (f(now.value)) {\n        if (now.prev) {\n          now.prev.next = now.next;\n        } else {\n          // now is front\n          this._linkedList.front = now.next;\n        }\n\n        if (now.next) {\n          now.next.prev = now.prev;\n        } else {\n          // now is end\n          this._linkedList.end = now.prev;\n        }\n\n        this._linkedList.size -= 1;\n        result.push(now.value);\n      }\n      now = now.next;\n    }\n\n    return result;\n  }\n\n  /**\n   * Same with removeMatch(f)\n   * @param {Function} f - Predicate\n   * @return {(*|undefined)} Found value. If not found, return undefined.\n   * @throws {TypeError} When the given predicate is not a function.\n   */\n  removeMatchFirst(f) {\n    return this.removeMatch(f);\n  }\n\n  /**\n   * Same with removeMatch(f) but find from start searching from last.\n   * @param {Function} f - Predicate\n   * @return {(*|undefined)} Found value. If not found, return undefined.\n   * @throws {TypeError} When the given predicate is not a function.\n   */\n  removeMatchLast(f) {\n    if (typeof f !== 'function') {\n      throw TypeError();\n    }\n\n    let now = this._linkedList.end;\n    while (now) {\n      if (f(now.value)) {\n        break;\n      }\n      now = now.prev;\n    }\n\n    if (!now) {\n      return undefined;\n    }\n\n    if (now.prev) {\n      now.prev.next = now.next;\n    } else {\n      // now is front\n      this._linkedList.front = now.next;\n    }\n\n    if (now.next) {\n      now.next.prev = now.prev;\n    } else {\n      // now is end\n      this._linkedList.end = now.prev;\n    }\n\n    this._linkedList.size -= 1;\n    return now.value;\n  }\n\n  /**\n   * Removes all values in the linked list.\n   */\n  clear() {\n    this._linkedList = {\n      size: 0,\n      front: null,\n      end: null,\n    };\n  }\n\n  /**\n   * Returns the value at the given index of the linked list.\n   * @param {number} index - The index to get the value.\n   * @return {*} The value at the given index of the linked list.\n   * When the given index < 0 or index >= size of the linked list, return undefined.\n   */\n  get(index) {\n    if (typeof index !== 'number' || index < 0 || index >= this._linkedList.size) {\n      return undefined;\n    }\n    const now = this._getNode(index);\n\n    return now.value;\n  }\n\n  /**\n   * Returns the value at the first of the linked list.\n   * @return {*} The value at the front of the linked list. If empty, return undefined.\n   */\n  getFirst() {\n    return this.get(0);\n  }\n\n  /**\n   * Returns the value at the end of the linked list.\n   * @return {*} The value at the end of the linked list. If empty, return undefined.\n   */\n  getLast() {\n    return this.get(this.size() - 1);\n  }\n\n  /**\n   * Updates the value at the given index of the linked list and\n   * returns the value at the given index of the linked list.\n   * @param {number} index - The index to update the value.\n   * @param {*} value - The value to update.\n   * @throws {RangeError} When the given index < 0 or index >= size of the linked list.\n   * @return {*} The value at the given index of the linked list.\n   */\n  set(index, value) {\n    if (typeof index !== 'number' || index < 0 || index >= this._linkedList.size) {\n      throw RangeError();\n    }\n    const now = this._getNode(index);\n\n    const ret = now.value;\n    now.value = value;\n\n    return ret;\n  }\n\n  /**\n   * Returns the value of the first element in the linked list\n   * that satisfies the provided testing function.\n   * @param {function} f - Testing function.\n   * @return {*} The the first value in the linked list\n   * that satisfies the provided testing function.\n   * When no element in the linked list satisfies the provided testing function, return undefined.\n   */\n  find(f) {\n    let now = this._linkedList.front;\n    while (now && !f(now.value)) {\n      now = now.next;\n    }\n    if (now) {\n      return now.value;\n    }\n    return undefined;\n  }\n\n  /**\n   * Returns the number of elements in the linked list.\n   * @return {number} The number of elements in the linked list.\n   */\n  size() {\n    return this._linkedList.size;\n  }\n\n  /**\n   * Returns whether the linked list is empty.\n   * @return {boolean} True if the linked list is empty.\n   */\n  isEmpty() {\n    return this._linkedList.size === 0;\n  }\n\n  /**\n   * For each values in the list, execute the given procedure f.\n   * @param {function} f - Procedure to execute\n   */\n  forEach(f) {\n    let now = this._linkedList.front;\n    while (now) {\n      f(now.value);\n      now = now.next;\n    }\n  }\n\n  /**\n   * Returns a new LinkedList whose values are mapped with given function f.\n   * @param {function} f - Function to map values\n   * @return {LinkedList} LinkedList([mapped values])\n   */\n  map(f) {\n    const list = new LinkedList();\n    this.forEach(v => list.addLast(f(v)));\n    return list;\n  }\n\n  /**\n   * Returns a new LinkedList whose values are mapped with given function f and flattened.\n   * @param {function} f - Function (this.value) => iterable\n   * @return {LinkedList} LinkedList([mapped and flattened values])\n   */\n  flatMap(f) {\n    const list = new LinkedList();\n    this.forEach(v => list.addAllLast([...f(v)]));\n    return list;\n  }\n\n  /**\n   * Returns a new LinkedList whose values are filtered with given predicate f.\n   * @param {function} f - Predicate (this.value) => boolean\n   * @return {LinkedList} LinkedList([filtered values])\n   */\n  filter(f) {\n    const list = new LinkedList();\n    this.forEach((v) => {\n      if (f(v)) {\n        list.addLast(v);\n      }\n    });\n    return list;\n  }\n\n  /**\n   * Returns a new LinkedList whose values are reversed in order.\n   * @return {LinkedList} LinkedList([reversed values])\n   */\n  reversed() {\n    const list = new LinkedList();\n    this.forEach(v => list.addFirst(v));\n    return list;\n  }\n\n  /**\n   * If any of containing values satisfies given f, return true.\n   * If none of values satisfy f or not contain any value, return false.\n   * @param {function} f - Predicate\n   * @return {boolean}\n   */\n  some(f) {\n    if (this.size() === 0) {\n      return false;\n    }\n\n    let now = this._linkedList.front;\n    while (now) {\n      if (f(now.value)) {\n        return true;\n      }\n      now = now.next;\n    }\n    return false;\n  }\n\n  /**\n   * If all of containing values satisfies given f or not contain any value, return true.\n   * If any of value doesn't satisfy f, return false.\n   * @param {function} f - Predicate\n   * @return {boolean}\n   */\n  every(f) {\n    let now = this._linkedList.front;\n    while (now) {\n      if (!f(now.value)) {\n        return false;\n      }\n      now = now.next;\n    }\n    return true;\n  }\n\n  /**\n   * If contains given value v, return true.\n   * @param {*} v\n   * @return {boolean}\n   */\n  includes(v) {\n    let now = this._linkedList.front;\n    while (now) {\n      if (now.value === v) {\n        return true;\n      }\n      now = now.next;\n    }\n    return false;\n  }\n\n  * [Symbol.iterator]() {\n    let now = this._linkedList.front;\n    while (now) {\n      yield now.value;\n      now = now.next;\n    }\n  }\n}\n\nmodule.exports = LinkedList;\n","const Utils = require('./utils');\nconst Optional = require('./optional');\nconst Stack = require('./stack');\nconst Queue = require('./queue');\nconst LinkedList = require('./linked-list');\nconst Heap = require('./heap');\nconst BinarySearchTree = require('./binary-search-tree');\n\n/**\n * @namespace sangja\n */\nmodule.exports = {\n  Optional,\n  Stack,\n  Queue,\n  LinkedList,\n  Heap,\n  BinarySearchTree,\n  isIterable: Utils.isIterable,\n  defaultKey: Utils.defaultKey,\n  defaultCompare: Utils.defaultCompare,\n};\n","/**\n * @class\n * @memberof sangja\n */\nclass Optional {\n  /**\n   * Creates a new Optional.\n   * Value parameter is optional. Undefeined for value is not allowed.(Not work well)\n   * @constructor\n   * @param {*} [value=undefined] - Value to contain\n   */\n  constructor(value = undefined) {\n    this.value = value;\n  }\n\n  /**\n   * Returns the containing value.\n   * @returns {*|undefined} The containing value. If it does not contain a value, return undefined\n   */\n  get() {\n    return this.value;\n  }\n\n  /**\n   * Returns the containing value.\n   * @returns {*} The containing value. If it does not contain a value, return undefined\n   */\n  getOrElse(value) {\n    if (this.value === undefined) {\n      return value;\n    }\n    return this.value;\n  }\n\n  /**\n   * If the optional contains a value, returns 1 else 0.\n   * @returns {number} The number of elements in the optional(0 or 1)\n   */\n  size() {\n    if (this.value === undefined) {\n      return 0;\n    }\n    return 1;\n  }\n\n  /**\n   * If the optional is empty, returns true else returns false.\n   * @returns {boolean} True if the optional is empty else false\n   */\n  isEmpty() {\n    if (this.value === undefined) {\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * If the optional contains a value, execute the given function f.\n   * @param {function} f - Function to execute\n   */\n  forEach(f) {\n    if (this.value === undefined) {\n      return;\n    }\n    f(this.value);\n  }\n\n  /**\n   * If the optional contains a value, execute the given function f\n   * and returns the new optional containing f(this.value).<br>\n   * If the optional is empty or catch error while executing f, returns empty optional.\n   * @param {function} f - Function to execute with this.value\n   * @return {Optional} Optional(f(this.value)) or Optional()\n   */\n  map(f) {\n    if (this.value === undefined) {\n      return new Optional();\n    }\n\n    try {\n      return new Optional(f(this.value));\n    } catch (err) {\n      return new Optional();\n    }\n  }\n\n  /**\n   * If the optional contains a value, execute the given function f\n   * and flatten the result.<br>\n   * Returns the new optional containing flatten result of f(this.value)<br>\n   * If the optional is empty or catch error while executing f, returns empty optional.\n   * @param {function} f - (this.value) => Optional\n   * @return {Optional} Optional(...f(this.value)) or Optional()\n   */\n  flatMap(f) {\n    if (this.value === undefined) {\n      return new Optional();\n    }\n\n    try {\n      return new Optional(...f(this.value));\n    } catch (err) {\n      return new Optional();\n    }\n  }\n\n  /**\n   * If the contained value satisfies the predicate, return this.\n   * If the optional is empty or given predicate returns false, returns empty optional.\n   * @param {function} f - Predicate\n   * @return {Optional} Optional(this.value) or Optional()\n   */\n  filter(f) {\n    if (this.value === undefined) {\n      return new Optional();\n    }\n\n    if (f(this.value)) {\n      return this;\n    }\n    return new Optional();\n  }\n\n  /**\n   * If containing value satisfies given f, return true.\n   * If not satisfy f or not contain any value, return false.\n   * @param {function} f - Predicate\n   * @returns {boolean}\n   */\n  some(f) {\n    if (this.value === undefined) {\n      return false;\n    }\n    return Boolean(f(this.value));\n  }\n\n  /**\n   * If not contain any value or containing value satisfies given f, return true.\n   * If not satisfy f, return false.\n   * @param {function} f - Predicate\n   * @returns {boolean}\n   */\n  every(f) {\n    if (this.value === undefined) {\n      return true;\n    }\n    return Boolean(f(this.value));\n  }\n\n  /**\n   * If contains given value v, return true.\n   * @param {*} v\n   * @returns {boolean}\n   */\n  includes(v) {\n    if (this.value !== undefined && this.value === v) {\n      return true;\n    }\n    return false;\n  }\n\n  * [Symbol.iterator]() {\n    if (this.value !== undefined) {\n      yield this.value;\n    }\n  }\n}\n\nmodule.exports = Optional;\n","const Utils = require('./utils');\n\n/**\n * @class\n * @memberof sangja\n */\nclass Stack {\n  /**\n   * Creates a new Stack.\n   * Iterable parameter is optional.\n   * @constructor\n   * @param {iterable} [iterable] - Iterator for initialize the stack.\n   * @throws {TypeError} When given parameter is not stack.\n   */\n  constructor(iterable = []) {\n    if (!Utils.isIterable(iterable)) {\n      throw TypeError();\n    }\n    this._stack = [...iterable];\n  }\n\n  /**\n   * Add value at the top of the stack.\n   * @param {*} value - The value to push to the stack.\n   */\n  push(value) {\n    this._stack.push(value);\n  }\n\n  /**\n   * Add values in the given iterator at the top of the stack.\n   * @param {iterable} iterable - The iterable values to push to the stack.\n   */\n  pushAll(iterable) {\n    [...iterable].forEach(v => this._stack.push(v));\n  }\n\n  /**\n   * Removes the top of the stack and returns the value at the top of the stack.\n   * @returns {*} The value at the top of the stack. If empty, return undefined.\n   */\n  pop() {\n    if (this._stack.length === 0) {\n      return undefined;\n    }\n\n    return this._stack.pop();\n  }\n\n  /**\n   * Returns the value at the top of the stack without changing the state of the stack.\n   * @returns {*} The value at the top of the stack. If empty, return undefined.\n   */\n  top() {\n    if (this._stack.length === 0) {\n      return undefined;\n    }\n\n    return this._stack[this._stack.length - 1];\n  }\n\n  /**\n   * Removes all values in the stack.\n   */\n  clear() {\n    this._stack = [];\n  }\n\n  /**\n   * Returns the number of elements in the stack.\n   * @returns {number} The number of elements in the stack.\n   */\n  size() {\n    return this._stack.length;\n  }\n\n  /**\n   * Returns whether the stack is empty.\n   * @returns {boolean} True if the stack is empty.\n   */\n  isEmpty() {\n    return this._stack.length === 0;\n  }\n\n  /**\n   * For each values in the stack, execute the given procedure f.<br>\n   * *Executing order is top to bottom*\n   * @param {function} f - Procedure to execute\n   */\n  forEach(f) {\n    for (let i = this._stack.length - 1; i >= 0; i -= 1) {\n      f(this._stack[i]);\n    }\n  }\n\n  /**\n   * Returns a stack whose values are mapped with given function f.\n   * @param {function} f - Function to map values\n   * @return {Stack} Stack([mapped values])\n   */\n  map(f) {\n    const stack = new Stack();\n    stack._stack = this._stack.map(f);\n    return stack;\n  }\n\n  /**\n   * Returns a stack whose values are mapped with given function f and flattened.\n   * @param {function} f - Function (this.value) => iterable\n   * @return {Stack} Stack([mapped and flattened values])\n   */\n  flatMap(f) {\n    const stack = new Stack();\n    // [...this._stack.map(f)].forEach(arr => arr.forEach(v => stack.push(v)));\n    this._stack.map(f).forEach(arr => stack.pushAll(arr));\n    return stack;\n  }\n\n  /**\n   * Returns a stack whose values are filtered with given predicate f.\n   * @param {function} f - Predicate (this.value) => boolean\n   * @return {Stack} Stack([filtered values])\n   */\n  filter(f) {\n    const stack = new Stack();\n    stack._stack = this._stack.filter(f);\n    return stack;\n  }\n\n  /**\n   * Returns a stack whose values are reversed in order.\n   * @return {Stack} Stack([reversed values])\n   */\n  reversed() {\n    return new Stack(this);\n  }\n\n  /**\n   * If any of containing values satisfies given f, return true.\n   * If none of values satisfy f or not contain any value, return false.\n   * @param {function} f - Predicate\n   * @returns {boolean}\n   */\n  some(f) {\n    return this._stack.some(f);\n  }\n\n  /**\n   * If all of containing values satisfies given f or not contain any value, return true.\n   * If any of value doesn't satisfy f, return false.\n   * @param {function} f - Predicate\n   * @returns {boolean}\n   */\n  every(f) {\n    return this._stack.every(f);\n  }\n\n  /**\n   * If contains given value v, return true.\n   * @param {*} v\n   * @returns {boolean}\n   */\n  includes(v) {\n    return this._stack.includes(v);\n  }\n\n  * [Symbol.iterator]() {\n    for (let i = this._stack.length - 1; i >= 0; i -= 1) {\n      yield this._stack[i];\n    }\n  }\n}\n\nmodule.exports = Stack;\n","const Utils = require('./utils');\n\n/**\n * @class\n * @memberof sangja\n */\nclass Heap {\n  /**\n   * Creates a new Heap.\n   * By default, max-heap is created.\n   * Iterable a and option object b are optional. But if both are given, a must precede b.\n   * @constructor\n   * @param {iterable} [a=[]] - Iterator for initialize\n   * @param {Object} [b={}] - Option object for initialize\n   * @param {function} [b.key=sangja.defaultKey] - Key function for each value.\n   * Each value should be comparable with given key.\n   * @param {function} [b.compare=sangja.defaultCompare] - Compare function.<br>\n   * If x precede y, compare(key(x), key(y)) < 0<br>\n   * If y precede x, compare(key(x), key(y)) > 0<br>\n   * If the order of x and y is the same, compare(key(x), key(y)) == 0\n   * @param {function} [b.reverse=false] - If true, compare result is inverted.\n   */\n  constructor(a = {}, b = {}) {\n    // null, null -> iterator: [], key,compare: default\n    // iterator, null -> iterator: ok, key,compare: default\n    // option, null -> iterator: [], key,compare: option\n    // iterator, option -> iterator: ok, key,compare: option\n    let iterator = null;\n    let key = null;\n    let compare = null;\n    let reverse = null;\n    if (Utils.isIterable(a)) {\n      iterator = a;\n      // If a is an iterable, b will be an option object.(If not given, {})\n      ({ key, compare, reverse } = b);\n    } else {\n      iterator = [];\n      // If a is not an iterable, a will be an option object.(If not given, {})\n      ({ key, compare, reverse } = a);\n    }\n\n    this._heap = [0];\n    this._options = {\n      key: key || Utils.defaultKey,\n      compare: compare || Utils.defaultCompare,\n      reverse: reverse || false,\n    };\n\n    this._key = this._options.key;\n    if (this._options.reverse) {\n      this._compare = (x, y) => this._options.compare(this._key(y), this._key(x));\n    } else {\n      this._compare = (x, y) => this._options.compare(this._key(x), this._key(y));\n    }\n\n    [...iterator].forEach(v => this.add(v));\n  }\n\n  /**\n   * Add value to the the heap.\n   * @param {*} value - The value to add\n   */\n  add(value) {\n    this._heap.push(value);\n\n    let now = this._heap.length - 1;\n    let next = Math.floor(now / 2);\n    while (now > 1 && this._compare(this._heap[next], this._heap[now]) < 0) {\n      const tmp = this._heap[next];\n      this._heap[next] = this._heap[now];\n      this._heap[now] = tmp;\n\n      now = next;\n      next = Math.floor(now / 2);\n    }\n  }\n\n  /**\n   * Add values to the the heap.\n   * @param {iterable} iterable - The iterable object that contain values to add.\n   */\n  addAll(iterable) {\n    [...iterable].forEach(v => this.add(v));\n  }\n\n  /**\n   * Removes the root of the heap and returns the value.\n   * @returns {*} The value at the root of the heap. If empty, return undefined.\n   */\n  pop() {\n    if (this._heap.length === 1) {\n      return undefined;\n    }\n    if (this._heap.length === 2) {\n      return this._heap.pop();\n    }\n\n    const value = this._heap[1];\n    this._heap[1] = this._heap.pop();\n\n    let now = 1;\n    while (now < this._heap.length) {\n      const left = now * 2;\n      const right = now * 2 + 1;\n      // If now < right child, now <- max(left, right) and continue\n      if (right < this._heap.length\n          && this._compare(this._heap[now], this._heap[right]) < 0) {\n        let next = null;\n        if (this._compare(this._heap[left], this._heap[right]) < 0) {\n          next = right;\n        } else {\n          next = left;\n        }\n        const tmp = this._heap[now];\n        this._heap[now] = this._heap[next];\n        this._heap[next] = tmp;\n        now = next;\n      } else if (left < this._heap.length\n          && this._compare(this._heap[now], this._heap[left]) < 0) {\n        const tmp = this._heap[now];\n        this._heap[now] = this._heap[left];\n        this._heap[left] = tmp;\n        now = left;\n      } else {\n        break;\n      }\n    }\n    return value;\n  }\n\n  /**\n   * Returns the value at the root of the heap without changing the state of the heap.\n   * @returns {*} The value at the root of the heap. If empty, return undefined.\n   */\n  peek() {\n    if (this._heap.length === 1) {\n      return undefined;\n    }\n\n    return this._heap[1];\n  }\n\n  /**\n   * Returns the value of the first element in the heap\n   * that satisfies the given predicate.<br>\n   * Searches matching value by bfs order.\n   * @param {function} f - Predicate\n   * @returns {(*|undefined)} The the first value in the heap\n   * that satisfies the provided testing function.\n   * When no element in the heap satisfies the provided testing function, return undefined.\n   */\n  find(f) {\n    for (let i = 1; i < this._heap.length; i += 1) {\n      if (f(this._heap[i])) {\n        return this._heap[i];\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * Returns the number of elements in the heap.\n   * @returns {number} The number of elements in the heap.\n   */\n  size() {\n    return this._heap.length - 1;\n  }\n\n  /**\n   * Returns whether the heap is empty.\n   * @returns {boolean} True if the heap is empty.\n   */\n  isEmpty() {\n    return this._heap.length === 1;\n  }\n\n  /**\n   * Removed all elements in the heap.\n   */\n  clear() {\n    this._heap = [0];\n  }\n\n  /**\n   * Execute the given procedure f for each values.\n   * @param {function} f - Procedure to execute\n   */\n  forEach(f) {\n    const heapForIter = new Heap(this._heap.slice(1), this._options);\n    while (!heapForIter.isEmpty()) {\n      f(heapForIter.pop());\n    }\n  }\n\n  /**\n   * Returns a new Heap mapped with given function f.\n   * @param {function} f - Function\n   * @param {Object} [options=this._options] - Option object for initialize the heap.<br>\n   * If not given, inherits from this.\n   * If only a portion is given, ingerits those that are not given.\n   * @return {Heap} Heap([mapped values])\n   */\n  map(f, options) {\n    const heap = new Heap(Utils.mergeOptions(options, this._options));\n    this.forEach(v => heap.add(f(v)));\n    return heap;\n  }\n\n  /**\n   * Returns a new Heap whose values are mapped with given function f and flattened.\n   * @param {function} f - Function (this.value) => iterable\n   * @param {Object} [options=this._options] - Option object for initialize the heap.<br>\n   * If not given, inherits from this.\n   * If only a portion is given, ingerits those that are not given.\n   * @return {Heap} Heap([mapped and flattened values])\n   */\n  flatMap(f, options) {\n    const heap = new Heap(Utils.mergeOptions(options, this._options));\n    this.forEach(v => heap.addAll([...f(v)]));\n    return heap;\n  }\n\n  /**\n   * Returns a new Heap whose values are filtered with given predicate f.\n   * @param {function} f - Predicate (this.value) => boolean\n   * @param {Object} [options=this._options] - Option object for initialize the heap.<br>\n   * If not given, inherits from this.\n   * If only a portion is given, ingerits those that are not given.\n   * @return {Heap} Heap([filtered values])\n   */\n  filter(f, options) {\n    const heap = new Heap(Utils.mergeOptions(options, this._options));\n    this.forEach((v) => {\n      if (f(v)) {\n        heap.add(v);\n      }\n    });\n    return heap;\n  }\n\n  /**\n   * Return new heap with same items, but reversed option is inverted from this.\n   * @return {Heap} Heap([reversed values])\n   */\n  reversed() {\n    return new Heap(this, Utils.mergeOptions({ reverse: !this._options.reverse }, this._options));\n  }\n\n  /**\n   * If any of containing values satisfies given f, return true.\n   * If none of values satisfy f or not contain any value, return false.\n   * @param {function} f - Predicate\n   * @returns {boolean}\n   */\n  some(f) {\n    for (let i = 1; i < this._heap.length; i += 1) {\n      if (f(this._heap[i])) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * If all of containing values satisfies given f or not contain any value, return true.\n   * If any of value doesn't satisfy f, return false.\n   * @param {function} f - Predicate\n   * @returns {boolean}\n   */\n  every(f) {\n    for (let i = 1; i < this._heap.length; i += 1) {\n      if (!f(this._heap[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * If contains given value v, return true.\n   * @param {*} v\n   * @returns {boolean}\n   */\n  includes(v) {\n    for (let i = 1; i < this._heap.length; i += 1) {\n      if (this._heap[i] === v) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  * [Symbol.iterator]() {\n    // Use other heap!\n    const heapForIter = new Heap(this._heap.slice(1), this._options);\n\n    while (!heapForIter.isEmpty()) {\n      yield heapForIter.pop();\n    }\n  }\n\n  /**\n   * Returns breadth first iterator.\n   * @param {Function} [f] - If f is given, execute f by bfs order.\n   * @returns {(generator|undefined)} Tree breadth first iterator. If f if given, not return.\n   */\n  // eslint-disable-next-line consistent-return\n  breadthFirst(f) {\n    if (!f) {\n      const that = this;\n      return (function* _breadthFirst() {\n        for (let i = 1; i < that._heap.length; i += 1) {\n          yield that._heap[i];\n        }\n      }());\n    }\n    for (let i = 1; i < this._heap.length; i += 1) {\n      f(this._heap[i]);\n    }\n  }\n}\n\nmodule.exports = Heap;\n","const Utils = require('./utils');\nconst Queue = require('./queue');\n\n/**\n * @class\n * @memberof sangja\n */\nclass BinarySearchTree {\n  /**\n   * Creates a new BinarySearchTree.\n   * Iterable a and option object b are optional. But if both are given, a must precede b.\n   * @constructor\n   * @param {iterable} [a=[]] - Iterator for initialize\n   * @param {Object} [b={}] - Option object\n   * @param {function} [b.key=utils.defaultKey] - Key function for each value.\n   * Each value should be comparable with given key.\n   * @param {function} [b.compare=utils.defaultCompare] - Compare function.<br>\n   * If x precede y, compare(key(x), key(y)) < 0<br>\n   * If y precede x, compare(key(x), key(y)) > 0<br>\n   * If the order of x and y is the same, compare(key(x), key(y)) == 0\n   * @param {function} [b.reverse=false] - If true, compare result is inverted.\n   */\n  constructor(a = {}, b = {}) {\n    // null, null -> iterator: [], key,compare: default\n    // iterator, null -> iterator: ok, key,compare: default\n    // option, null -> iterator: [], key,compare: option\n    // iterator, option -> iterator: ok, key,compare: option\n    let iterator = null;\n    let key = null;\n    let compare = null;\n    let reverse = null;\n    if (Utils.isIterable(a)) {\n      iterator = a;\n      // If a is an iterable, b will be an option object.(If not given, {})\n      ({ key, compare, reverse } = b);\n    } else {\n      iterator = [];\n      // If a is not an iterable, a will be an option object.(If not given, {})\n      ({ key, compare, reverse } = a);\n    }\n\n    this._root = null;\n    this._options = {\n      key: key || Utils.defaultKey,\n      compare: compare || Utils.defaultCompare,\n      reverse: reverse || false,\n    };\n\n    this._key = this._options.key;\n    if (this._options.reverse) {\n      this._compare = (x, y) => this._options.compare(this._key(y), this._key(x));\n    } else {\n      this._compare = (x, y) => this._options.compare(this._key(x), this._key(y));\n    }\n\n    [...iterator].forEach(v => this.add(v));\n  }\n\n  /**\n   * Add value to the tree.\n   * @param {*} value - The value to add to the tree.\n   */\n  add(value) {\n    if (this._root == null) {\n      this._root = {\n        left: null,\n        right: null,\n        children: 0,\n        value,\n      };\n      return;\n    }\n\n    let parent = null;\n    let now = this._root;\n    let direction = null; // 0 if left else 1;\n    while (now) {\n      parent = now;\n      now.children += 1;\n      if (this._compare(value, now.value) <= 0) {\n        now = now.left;\n        direction = 0;\n      } else {\n        now = now.right;\n        direction = 1;\n      }\n    }\n\n    now = {\n      left: null,\n      right: null,\n      children: 0,\n      value,\n    };\n    if (direction === 0) {\n      parent.left = now;\n    } else {\n      parent.right = now;\n    }\n  }\n\n  /**\n   * Add values to the the tree.\n   * @param {iterable} iterable - The iterable object that contain values to add.\n   */\n  addAll(iterable) {\n    [...iterable].forEach(v => this.add(v));\n  }\n\n  /**\n   * Removes the lowest value of the tree and returns the value.\n   * @returns {*} The lowest value of the tree. If empty, return undefined.\n   */\n  pop() {\n    if (this._root === null) {\n      return undefined;\n    }\n\n    let parent = null;\n    let now = this._root;\n    while (now.left) {\n      now.children -= 1;\n      parent = now;\n      now = now.left;\n    }\n\n    if (parent !== null) {\n      parent.left = now.right;\n    } else {\n      this._root = now.right;\n    }\n\n    return now.value;\n  }\n\n  /**\n   * Removes the given value in the tree and returns the value.\n   * @returns {(*|undefined)} The lowest value of the tree. If empty or not found, return undefined.\n   */\n  remove(v) {\n    if (this._root === null || !this.includes(v)) {\n      return undefined;\n    }\n\n    let parent = null;\n    let now = this._root;\n    while (now) {\n      const comp = this._compare(this._key(v), this._key(now.value));\n      if (comp === 0) {\n        break;\n      } else if (comp < 0) {\n        now.children -= 1;\n        parent = now;\n        now = now.left;\n      } else {\n        now.children -= 1;\n        parent = now;\n        now = now.right;\n      }\n    }\n\n    // Not found\n    if (now === null) {\n      return undefined;\n    }\n\n    // If now has both child, move left rightmost child.\n    if (now.left && now.right) {\n      let rightmostParent = now;\n      let rightmost = now.left;\n      while (rightmost.right) {\n        rightmostParent.children -= 1;\n        rightmostParent = rightmost;\n        rightmost = rightmost.right;\n      }\n      if (rightmostParent !== now) {\n        // Found rightmost.\n        rightmostParent.right = rightmost.left;\n      } else {\n        // Rightmost is now.left\n        rightmostParent.left = rightmost.left;\n      }\n      const result = now.value;\n      now.value = rightmost.value;\n      return result;\n    }\n\n    // If now has left child, remove now.\n    if (now.left) {\n      if (now === this._root) {\n        this._root = now.left;\n      } else if (parent.left === now) {\n        parent.left = now.left;\n      } else {\n        parent.right = now.left;\n      }\n      return now.value;\n    }\n\n    // If now has right child, remove now.\n    if (now.right) {\n      if (now === this._root) {\n        this._root = now.right;\n      } else if (parent.left === now) {\n        parent.left = now.right;\n      } else {\n        parent.right = now.right;\n      }\n      return now.value;\n    }\n\n    // If now is left, remove now from parent.\n    if (now === this._root) {\n      this._root = null;\n    } else if (parent.left === now) {\n      parent.left = null;\n    } else {\n      parent.right = null;\n    }\n    return now.value;\n  }\n\n  /**\n   * Removes a value that matches given predicate f and\n   * returns value in the linked list.\n   * @param {Function} f - Predicate\n   * @returns {(*|undefined)} Found value. If not found, return undefined.\n   * @throws {TypeError} When the given predicate is not a function.\n   */\n  removeMatch(f) {\n    if (typeof f !== 'function') {\n      throw TypeError();\n    }\n\n    if (this.isEmpty()) {\n      return undefined;\n    }\n\n    function _getMatch(node) {\n      if (f(node.value)) {\n        return node.value;\n      }\n      return (node.left && _getMatch(node.left))\n        || (node.right && _getMatch(node.right));\n    }\n    const removeVal = _getMatch(this._root);\n    this.remove(removeVal);\n    return removeVal;\n  }\n\n  /**\n   * Returns the lowest value of the tree without changing the state of the tree.\n   * @returns {*} The lowest value of the tree. If empty, return undefined.\n   */\n  peek() {\n    if (this._root === null) {\n      return undefined;\n    }\n\n    let now = this._root;\n    while (now) {\n      if (now.left) {\n        now = now.left;\n      }\n    }\n\n    return now.value;\n  }\n\n  /**\n   * Returns the value of the first element in the binary search tree\n   * that satisfies the given predicate.<br>\n   * Searches matching value by dfs order(preorder).\n   * @param {function} f - Predicate\n   * @returns {(*|undefined)} The the first value in the binary search tree\n   * that satisfies the provided testing function.\n   * When no element in the binary search tree satisfies\n   * the provided testing function, return undefined.\n   */\n  find(f) {\n    const nodes = [this._root];\n    while (nodes.length > 0) {\n      const now = nodes.pop();\n      if (now) {\n        if (f(now.value)) {\n          return now.value;\n        }\n        nodes.push(now.left);\n        nodes.push(now.right);\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * Returns the number of elements in the tree.\n   * @returns {number} The number of elements in the tree.\n   */\n  size() {\n    if (this._root === null) {\n      return 0;\n    }\n\n    return this._root.children + 1;\n  }\n\n  /**\n   * Returns whether the tree is empty.\n   * @returns {boolean} True if the tree is empty.\n   */\n  isEmpty() {\n    return this._root === null;\n  }\n\n  /**\n   * Removed all elements in the tree.\n   */\n  clear() {\n    this._root = null;\n  }\n\n  /**\n   * Execute the given procedure f for each values.\n   * @param {function} f - Procedure to execute\n   */\n  forEach(f) {\n    function _forEach(node) {\n      if (node) {\n        f(node.value);\n        _forEach(node.left);\n        _forEach(node.right);\n      }\n    }\n\n    _forEach(this._root);\n  }\n\n  /**\n   * Returns a new BinarySearchTree mapped with given function f.\n   * @param {function} f - Function\n   * @param {Object} [options=this._options] - Option object for initialize.<br>\n   * If not given, inherits from this.\n   * If only a portion is given, ingerits those that are not given.\n   * @return {BinarySearchTree} BinarySearchTree([mapped values])\n   */\n  map(f, options) {\n    const tree = new this.constructor(Utils.mergeOptions(options, this._options));\n    this.forEach(v => tree.add(f(v)));\n    return tree;\n  }\n\n  /**\n   * Returns a new BinarySearchTree whose values are mapped with given function f and flattened.\n   * @param {function} f - Function (this.value) => iterable\n   * @param {Object} [options=this._options] - Option object for initialize.<br>\n   * If not given, inherits from this.\n   * If only a portion is given, ingerits those that are not given.\n   * @return {BinarySearchTree} BinarySearchTree([mapped and flattened values])\n   */\n  flatMap(f, options) {\n    const tree = new this.constructor(Utils.mergeOptions(options, this._options));\n    this.forEach(v => tree.addAll([...f(v)]));\n    return tree;\n  }\n\n  /**\n   * Returns a new BinarySearchTree whose values are filtered with given predicate f.\n   * @param {function} f - Predicate (this.value) => boolean\n   * @param {Object} [options=this._options] - Option object for initialize.<br>\n   * If not given, inherits from this.\n   * If only a portion is given, ingerits those that are not given.\n   * @return {BinarySearchTree} BinarySearchTree([filtered values])\n   */\n  filter(f, options) {\n    const tree = new this.constructor(Utils.mergeOptions(options, this._options));\n    this.forEach((v) => {\n      if (f(v)) {\n        tree.add(v);\n      }\n    });\n    return tree;\n  }\n\n  /**\n   * Return new tree with same items, but reversed option is inverted from this.\n   * @return {BinarySearchTree} BinarySearchTree([reversed values])\n   */\n  reversed() {\n    return new this.constructor(this,\n      Utils.mergeOptions({ reverse: !this._options.reverse }, this._options));\n  }\n\n  /**\n   * If any of containing values satisfies given f, return true.\n   * If none of values satisfy f or not contain any value, return false.\n   * @param {function} f - Predicate\n   * @returns {boolean}\n   */\n  some(f) {\n    function _some(node) {\n      return f(node.value)\n        || Boolean(node.left && _some(node.left))\n        || Boolean(node.right && _some(node.right));\n    }\n    return Boolean(this._root) && _some(this._root);\n  }\n\n  /**\n   * If all of containing values satisfies given f or not contain any value, return true.\n   * If any of value doesn't satisfy f, return false.\n   * @param {function} f - Predicate\n   * @returns {boolean}\n   */\n  every(f) {\n    function _every(node) {\n      return f(node.value)\n        && Boolean(!node.left || _every(node.left))\n        && Boolean(!node.right || _every(node.right));\n    }\n    return !this._root || _every(this._root);\n  }\n\n  /**\n   * If contains given value v, return true.\n   * @param {*} v\n   * @returns {boolean}\n   */\n  includes(v) {\n    let now = this._root;\n    while (now) {\n      const comp = this._compare(this._key(v), this._key(now.value));\n      if (comp === 0) {\n        return true;\n      }\n      if (comp < 0) {\n        now = now.left;\n      } else {\n        now = now.right;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Returns whether the tree is empty.\n   * @name Symbol.iterator\n   * @generator\n   * @property {generator}\n   * @returns {boolean} True if the tree is empty.\n   */\n  * [Symbol.iterator]() {\n    yield* this.inorder();\n  }\n\n  /**\n   * Returns inorder iterator.\n   * @param {Function} [f] - If f is given, execute f by inorder.\n   * @returns {(generator|undefined)} Tree inorder iterator. If f if given, not return.\n   */\n  // eslint-disable-next-line consistent-return\n  inorder(f) {\n    if (!f) {\n      return (function* _inorderIterator(node) {\n        if (node !== null) {\n          yield* _inorderIterator(node.left);\n          yield node.value;\n          yield* _inorderIterator(node.right);\n        }\n      }(this._root));\n    }\n\n    function _inorder(node) {\n      if (node !== null) {\n        _inorder(node.left);\n        f(node.value);\n        _inorder(node.right);\n      }\n    }\n    _inorder(this._root);\n  }\n\n  /**\n   * Returns preorder iterator.\n   * @param {Function} [f] - If f is given, execute f by preorder.\n   * @returns {(generator|undefined)} Tree preorder iterator. If f if given, not return.\n   */\n  // eslint-disable-next-line consistent-return\n  preorder(f) {\n    if (!f) {\n      return (function* _preorderIterator(node) {\n        if (node !== null) {\n          yield node.value;\n          yield* _preorderIterator(node.left);\n          yield* _preorderIterator(node.right);\n        }\n      }(this._root));\n    }\n\n    function _preorder(node) {\n      if (node !== null) {\n        f(node.value);\n        _preorder(node.left);\n        _preorder(node.right);\n      }\n    }\n    _preorder(this._root);\n  }\n\n  /**\n   * Returns postorder iterator.\n   * @param {Function} [f] - If f is given, execute f by postorder.\n   * @returns {(generator|undefined)} Tree postorder iterator. If f if given, not return.\n   */\n  // eslint-disable-next-line consistent-return\n  postorder(f) {\n    if (!f) {\n      return (function* _postorderIterator(node) {\n        if (node !== null) {\n          yield* _postorderIterator(node.left);\n          yield* _postorderIterator(node.right);\n          yield node.value;\n        }\n      }(this._root));\n    }\n\n    function _postorder(node) {\n      if (node !== null) {\n        _postorder(node.left);\n        _postorder(node.right);\n        f(node.value);\n      }\n    }\n    _postorder(this._root);\n  }\n\n  /**\n   * Returns breadth first iterator.\n   * @param {Function} [f] - If f is given, execute f by breadth first.\n   * @returns {(generator|undefined)} Tree breadth first iterator. If f if given, not return.\n   */\n  // eslint-disable-next-line consistent-return\n  breadthFirst(f) {\n    if (!f) {\n      return (function* _breadthFirstIterator(root) {\n        const queue = new Queue();\n        queue.enqueue(root);\n        while (queue.size() > 0) {\n          const now = queue.dequeue();\n          if (now !== undefined && now !== null) {\n            yield now.value;\n            queue.enqueue(now.left);\n            queue.enqueue(now.right);\n          }\n        }\n      }(this._root));\n    }\n\n    function _breadthFirst(root) {\n      const queue = new Queue();\n      queue.enqueue(root);\n      while (queue.size() > 0) {\n        const now = queue.dequeue();\n        if (now !== undefined && now !== null) {\n          f(now.value);\n          queue.enqueue(now.left);\n          queue.enqueue(now.right);\n        }\n      }\n    }\n    _breadthFirst(this._root);\n  }\n}\n\nmodule.exports = BinarySearchTree;\n"],"sourceRoot":""}