@x-oasis/integer-buffer-set 0.1.20 → 0.1.24

package/dist/index.d.ts

@@ -1,8 +1,7 @@
 import Heap from '@x-oasis/heap';
-import { HeapItem, SafeRange, IntegerBufferSetProps, MetaToIndexMap, MetaToPositionMap } from './types';
+import { HeapItem, SafeRange, IntegerBufferSetProps, MetaToIndexMap } from './types';
 export declare const defaultBufferSize = 10;
 declare class IntegerBufferSet<Meta = any> {
-    private _size;
     private _name;
     private _bufferSize;
     private _indexToMetaMap;
@@ -19,15 +18,15 @@ declare class IntegerBufferSet<Meta = any> {
     private _loopMS;
     private _lastUpdatedMS;
     constructor(props?: IntegerBufferSetProps<Meta>);
-    getSize(): number;
     get bufferSize(): number;
+    isThresholdMeta(meta: any): boolean;
     setIsOnTheFlyFull(val: any): void;
+    resetOnTheFlies(): void;
     get isBufferFull(): boolean;
     getOnTheFlyUncriticalPosition(safeRange: SafeRange): number;
     initialize(): {
         smallValues: Heap<any>;
         largeValues: Heap<any>;
-        valueToPositionObject: {};
     };
     getIndexMeta(index: number): Meta;
     getMetaIndex(meta: Meta): number;
@@ -38,13 +37,7 @@ declare class IntegerBufferSet<Meta = any> {
     getNewPositionForIndex(index: number): number;
     getMinValue(): number;
     getMaxValue(): number;
-    setValuePosition(value: number, position: number): void;
-    findPositionMeta(position: number): Meta;
-    rebuildHeapsWithMeta(metaToPositionMap: MetaToPositionMap<Meta>): void;
-    setPositionIndex(position: number, index: number): boolean;
-    getMetaPosition(meta: Meta): number;
-    replacePositionInFliedIndices(newIndex: number, safeRange: SafeRange): number;
-    getFliedPosition(newIndex: number, safeRange: SafeRange): any;
+    getFliedPosition(newIndex: number, safeRange: SafeRange): number;
     getPosition(newIndex: number, safeRange?: SafeRange): any;
     replaceFurthestIndexPosition(newIndex: number, safeRange?: {
         startIndex: number;
@@ -54,20 +47,21 @@ declare class IntegerBufferSet<Meta = any> {
         startIndex: number;
         endIndex: number;
     }): any;
-    shuffle(): any[];
-    getIndices(): any[];
+    shuffle(): any;
+    getIndices(): any;
     _pushToHeaps(position: number, value: number): void;
     _setMetaPosition(meta: Meta, position: number): void;
+    commitPosition(props: {
+        newIndex: number;
+        position: number;
+        meta: Meta;
+        safeRange: SafeRange;
+    }): number;
     _setMetaIndex(meta: Meta, index: number): boolean;
     readyToStartNextLoop(): void;
     prepare(): void;
     _cleanHeaps(): void;
-    rebuildHeapsWithValues(arr: Array<{
-        position: number;
-        value: number;
-    }>): void;
     _recreateHeaps(): void;
-    _cleanHeap(heap: Heap<HeapItem>): void;
     _smallerComparator(lhs: HeapItem, rhs: HeapItem): boolean;
     _greaterComparator(lhs: HeapItem, rhs: HeapItem): boolean;
 }

package/dist/integer-buffer-set.cjs.development.js

@@ -26,37 +26,6 @@ function _createClass(Constructor, protoProps, staticProps) {
   });
   return Constructor;
 }
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-  return arr2;
-}
-function _createForOfIteratorHelperLoose(o, allowArrayLike) {
-  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-  if (it) return (it = it.call(o)).next.bind(it);
-  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-    if (it) o = it;
-    var i = 0;
-    return function () {
-      if (i >= o.length) return {
-        done: true
-      };
-      return {
-        done: false,
-        value: o[i++]
-      };
-    };
-  }
-  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
 function _toPrimitive(input, hint) {
   if (typeof input !== "object" || input === null) return input;
   var prim = input[Symbol.toPrimitive];
@@ -76,6 +45,7 @@ var defaultMetaExtractor = function defaultMetaExtractor(value) {
   return value;
 };
 var defaultBufferSize = 10;
+var thresholdNumber = Number.MAX_SAFE_INTEGER - 100000;
 var IntegerBufferSet = /*#__PURE__*/function () {
   function IntegerBufferSet(props) {
     if (props === void 0) {
@@ -97,37 +67,39 @@ var IntegerBufferSet = /*#__PURE__*/function () {
     this._positionToMetaList = [];
     this._metaToIndexMap = new Map();
     this._onTheFlyIndices = [];
-    this._size = 0;
     this._bufferSize = bufferSize;
     this._smallValues = new Heap([], this._smallerComparator);
     this._largeValues = new Heap([], this._greaterComparator);
     this.getNewPositionForIndex = this.getNewPositionForIndex.bind(this);
     this.getIndexPosition = this.getIndexPosition.bind(this);
-    this.getSize = this.getSize.bind(this);
-    this.replacePositionInFliedIndices = this.replacePositionInFliedIndices.bind(this);
     this.replaceFurthestIndexPosition = this.replaceFurthestIndexPosition.bind(this);
     this._isOnTheFlyFullReturnHook = returnHook(this.setIsOnTheFlyFull.bind(this));
     this._loopMS = Date.now();
     this._lastUpdatedMS = this._loopMS;
   }
   var _proto = IntegerBufferSet.prototype;
-  _proto.getSize = function getSize() {
-    return this._size;
+  _proto.isThresholdMeta = function isThresholdMeta(meta) {
+    if (typeof meta === 'number' && meta > thresholdNumber) return true;
+    return false;
   };
   _proto.setIsOnTheFlyFull = function setIsOnTheFlyFull(val) {
     if (val != null) {
       var data = this._onTheFlyIndices.filter(function (v) {
-        return v;
+        return v != null;
       });
       this._isOnTheFlyFull = data.length === this._bufferSize;
     }
   };
+  _proto.resetOnTheFlies = function resetOnTheFlies() {
+    this._isOnTheFlyFull = false;
+    this._onTheFlyIndices = [];
+  };
   _proto.getOnTheFlyUncriticalPosition = function getOnTheFlyUncriticalPosition(safeRange) {
     var startIndex = safeRange.startIndex,
       endIndex = safeRange.endIndex;
     for (var idx = 0; idx < this._onTheFlyIndices.length; idx++) {
       var meta = this._onTheFlyIndices[idx];
-      var metaIndex = this._metaToIndexMap.get(meta);
+      var metaIndex = this.getMetaIndex(meta);
       if (!isClamped(startIndex, metaIndex, endIndex)) {
         return idx;
       }
@@ -137,14 +109,16 @@ var IntegerBufferSet = /*#__PURE__*/function () {
   _proto.initialize = function initialize() {
     return {
       smallValues: new Heap([], this._smallerComparator),
-      largeValues: new Heap([], this._greaterComparator),
-      valueToPositionObject: {}
+      largeValues: new Heap([], this._greaterComparator)
     };
   };
   _proto.getIndexMeta = function getIndexMeta(index) {
+    if (index == null || index < 0) return null;
     return this._metaExtractor(index);
   };
   _proto.getMetaIndex = function getMetaIndex(meta) {
+    if (meta == null) return -1;
+    if (this.isThresholdMeta(meta)) return -1;
     if (this._indexExtractor) return this._indexExtractor(meta);
     return this._metaToIndexMap.get(meta);
   };
@@ -183,111 +157,53 @@ var IntegerBufferSet = /*#__PURE__*/function () {
     var _this$_largeValues$pe;
     return (_this$_largeValues$pe = this._largeValues.peek()) == null ? void 0 : _this$_largeValues$pe.value;
   };
-  _proto.setValuePosition = function setValuePosition(value, position) {};
-  _proto.findPositionMeta = function findPositionMeta(position) {
-    for (var _iterator = _createForOfIteratorHelperLoose(this._metaToPositionMap), _step; !(_step = _iterator()).done;) {
-      var _step$value = _step.value,
-        meta = _step$value[0],
-        pos = _step$value[1];
-      if (pos === position) return meta;
-    }
-    return null;
-  };
-  _proto.rebuildHeapsWithMeta = function rebuildHeapsWithMeta(metaToPositionMap) {
-    var _this$initialize = this.initialize(),
-      smallValues = _this$initialize.smallValues,
-      largeValues = _this$initialize.largeValues;
-    for (var _iterator2 = _createForOfIteratorHelperLoose(metaToPositionMap), _step2; !(_step2 = _iterator2()).done;) {
-      var _step2$value = _step2.value,
-        meta = _step2$value[0],
-        position = _step2$value[1];
-      var index = this.getMetaIndex(meta);
-      var token = {
-        index: index,
-        position: position
-      };
-      smallValues.push(token);
-      largeValues.push(token);
-    }
-    this._smallValues = smallValues;
-    this._largeValues = largeValues;
-  };
-  _proto.setPositionIndex = function setPositionIndex(position, index) {
-    var meta = this._metaExtractor(index);
-    var originalPosition = this._metaToPositionMap.get(meta);
-    if (originalPosition !== undefined) {
-      if (originalPosition === position) return true;
-      this.deleteMetaIndex(meta);
-    }
-    var metaToReplace = this.findPositionMeta(position);
-    if (metaToReplace) this._metaToPositionMap["delete"](metaToReplace);
-    this._metaToPositionMap.set(meta, position);
-    this.rebuildHeapsWithMeta(this._metaToPositionMap);
-    return true;
-  };
-  _proto.getMetaPosition = function getMetaPosition(meta) {
-    return this._metaToPositionMap.get(meta);
-  };
-  _proto.replacePositionInFliedIndices = function replacePositionInFliedIndices(newIndex, safeRange) {
-    var startIndex = safeRange.startIndex,
-      endIndex = safeRange.endIndex;
+  _proto.getFliedPosition = function getFliedPosition(newIndex, safeRange) {
     if (this._isOnTheFlyFull) {
-      if (!isClamped(startIndex, newIndex, endIndex)) {
-        return null;
+      if (safeRange && isClamped(safeRange.startIndex, newIndex, safeRange.endIndex)) {
+        return this.getOnTheFlyUncriticalPosition(safeRange);
       }
-      var pos = this.getOnTheFlyUncriticalPosition(safeRange);
-      if (pos != null) return pos;
-    }
-    return null;
-  };
-  _proto.getFliedPosition = function getFliedPosition(newIndex, safeRange) {
-    var pos = this.replacePositionInFliedIndices(newIndex, safeRange);
-    if (pos != null) {
-      var meta = this.getIndexMeta(newIndex);
-      this._onTheFlyIndices[pos] = meta;
-      this._setMetaIndex(meta, newIndex);
-      return this._isOnTheFlyFullReturnHook(pos);
     }
     return null;
   };
   _proto.getPosition = function getPosition(newIndex, safeRange) {
     this.prepare();
     var meta = this.getIndexMeta(newIndex);
-    var prevMetaPosition = this._metaToPositionMap.get(meta);
-    if (prevMetaPosition !== undefined) {
-      var onTheFlyPositionMeta = this._onTheFlyIndices[prevMetaPosition];
-      if (onTheFlyPositionMeta) {
-        if (onTheFlyPositionMeta === meta) {
-          return prevMetaPosition;
-        }
-        var _positionToReplace = this._replaceFurthestIndexPosition(newIndex, safeRange);
-        if (this._isOnTheFlyFull) return this.getFliedPosition(newIndex, safeRange);
-        while (this._onTheFlyIndices[_positionToReplace]) {
-          _positionToReplace = this._replaceFurthestIndexPosition(newIndex, safeRange);
-        }
-        if (_positionToReplace != null) {
-          this._setMetaIndex(meta, newIndex);
-          this._onTheFlyIndices[_positionToReplace] = onTheFlyPositionMeta;
-          return this._isOnTheFlyFullReturnHook(_positionToReplace);
-        }
-      }
-      this._onTheFlyIndices[prevMetaPosition] = meta;
-      return this._isOnTheFlyFullReturnHook(prevMetaPosition);
-    }
-    if (!this.isBufferFull) return this._isOnTheFlyFullReturnHook(this.getNewPositionForIndex(newIndex));
-    if (this._isOnTheFlyFull) return this.getFliedPosition(newIndex, safeRange);
-    var positionToReplace;
-    var prevIndexMeta = this._indexToMetaMap.get(newIndex);
-    if (!prevIndexMeta) {
-      this._cleanHeaps();
-      positionToReplace = this._replaceFurthestIndexPosition(newIndex, safeRange);
+    var metaPosition = this._metaToPositionMap.get(meta);
+    var position, indexMeta;
+    if (metaPosition !== undefined) {
+      position = this.commitPosition({
+        newIndex: newIndex,
+        meta: meta,
+        safeRange: safeRange,
+        position: metaPosition
+      });
+    } else if (!this.isBufferFull) {
+      position = this.getNewPositionForIndex(newIndex);
+    } else if (this._isOnTheFlyFull) {
+      position = this.getFliedPosition(newIndex, safeRange);
+    } else if ((indexMeta = this._indexToMetaMap.get(newIndex)) && this._metaToPositionMap.get(indexMeta)) {
+      position = this.commitPosition({
+        newIndex: newIndex,
+        meta: meta,
+        safeRange: safeRange,
+        position: this._metaToPositionMap.get(indexMeta)
+      });
     } else {
-      positionToReplace = this._metaToPositionMap.get(prevIndexMeta);
+      this._cleanHeaps();
+      position = this.commitPosition({
+        newIndex: newIndex,
+        meta: meta,
+        safeRange: safeRange,
+        position: this._replaceFurthestIndexPosition(newIndex, safeRange)
+      });
     }
-    this._onTheFlyIndices[positionToReplace] = meta;
-    this._setMetaIndex(meta, newIndex);
-    this._setMetaPosition(meta, positionToReplace);
-    return this._isOnTheFlyFullReturnHook(positionToReplace);
+    if (position != null) {
+      this._onTheFlyIndices[position] = meta;
+      this._setMetaIndex(meta, newIndex);
+      this._metaToPositionMap.set(meta, position);
+      return this._isOnTheFlyFullReturnHook(position);
+    }
+    return null;
   };
   _proto.replaceFurthestIndexPosition = function replaceFurthestIndexPosition(newIndex, safeRange) {
     if (!this.isBufferFull) {
@@ -299,9 +215,16 @@ var IntegerBufferSet = /*#__PURE__*/function () {
     if (this._largeValues.empty() || this._smallValues.empty()) {
       return this._isOnTheFlyFullReturnHook(this.getNewPositionForIndex(newIndex));
     }
+    var indexToReplace;
     var minValue = this._smallValues.peek().value;
     var maxValue = this._largeValues.peek().value;
-    var indexToReplace;
+    if (maxValue > thresholdNumber) {
+      indexToReplace = maxValue;
+      this._largeValues.pop();
+      var _replacedMeta = this._indexToMetaMap.get(indexToReplace);
+      var _position = this._metaToPositionMap.get(_replacedMeta);
+      return _position;
+    }
     if (!safeRange) {
       if (Math.abs(newIndex - minValue) > Math.abs(newIndex - maxValue)) {
         indexToReplace = minValue;
@@ -310,9 +233,9 @@ var IntegerBufferSet = /*#__PURE__*/function () {
         indexToReplace = maxValue;
         this._largeValues.pop();
       }
-      var _replacedMeta = this._indexToMetaMap.get(indexToReplace);
-      var _position = this._metaToPositionMap.get(_replacedMeta);
-      return _position;
+      var _replacedMeta2 = this._indexToMetaMap.get(indexToReplace);
+      var _position2 = this._metaToPositionMap.get(_replacedMeta2);
+      return _position2;
     }
     var lowValue = safeRange.startIndex,
       highValue = safeRange.endIndex;
@@ -347,7 +270,6 @@ var IntegerBufferSet = /*#__PURE__*/function () {
     var _available = [];
     var indexToMetaMap = new Map();
     var metaToIndexMap = new Map();
-    var metaToPositionMap = new Map();
     var _loop = function _loop() {
       var currentIndex = indices[_idx];
       var currentMeta = _this._metaExtractor(currentIndex);
@@ -371,71 +293,43 @@ var IntegerBufferSet = /*#__PURE__*/function () {
       var _ret = _loop();
       if (_ret === "continue") continue;
     }
-    var _this$initialize2 = this.initialize(),
-      smallValues = _this$initialize2.smallValues,
-      largeValues = _this$initialize2.largeValues;
     var positionToMetaList = [];
+    this._indexToMetaMap = indexToMetaMap;
+    this.replaceMetaToIndexMap(metaToIndexMap);
     for (var position = 0; position < indices.length; position++) {
-      var value = indices[position];
       if (_arr[position] != null) {
         positionToMetaList[position] = _arr[position];
-        metaToPositionMap.set(_arr[position], position);
-        var element = {
-          position: position,
-          value: value
-        };
-        smallValues.push(element);
-        largeValues.push(element);
         continue;
       }
       var _meta = _available.shift();
       if (_meta != null) {
         positionToMetaList[position] = _meta;
-        metaToPositionMap.set(_meta, position);
-        var _element = {
-          position: position,
-          value: value
-        };
-        smallValues.push(_element);
-        largeValues.push(_element);
       }
     }
     this._positionToMetaList = positionToMetaList;
-    this._smallValues = smallValues;
-    this._largeValues = largeValues;
-    this._indexToMetaMap = indexToMetaMap;
-    this.replaceMetaToIndexMap(metaToIndexMap);
-    this._metaToPositionMap = metaToPositionMap;
-    this._onTheFlyIndices = [];
-    try {
-      var _indices = new Array(this.bufferSize);
-      for (var _idx2 = 0; _idx2 < _indices.length; _idx2++) {
-        var _meta2 = this._onTheFlyIndices[_idx2] || this._positionToMetaList[_idx2];
-        var _targetIndex = this.getMetaIndex(_meta2);
-        if (_meta2 != null) {
-          _indices[_idx2] = {
-            meta: _meta2,
-            targetIndex: _targetIndex,
-            recyclerKey: this._name + "_" + _idx2
-          };
-        }
-      }
-      return _indices;
-    } catch (err) {
-      this.readyToStartNextLoop();
-      return this._positionToMetaList;
-    }
+    return this.getIndices();
   };
   _proto.getIndices = function getIndices() {
+    var _this$initialize = this.initialize(),
+      smallValues = _this$initialize.smallValues,
+      largeValues = _this$initialize.largeValues;
     try {
-      var indices = new Array(this.bufferSize);
+      var indices = new Array(this._positionToMetaList.length);
+      var metaToPositionMap = new Map();
       for (var idx = 0; idx < indices.length; idx++) {
         var meta = this._onTheFlyIndices[idx] || this._positionToMetaList[idx];
         var targetIndex = this.getMetaIndex(meta);
-        if (meta !== this.getIndexMeta(targetIndex)) {
+        if (!this.isThresholdMeta(meta) && meta != this.getIndexMeta(targetIndex)) {
           return this.shuffle();
         }
-        if (meta != null) {
+        if (meta != null && !this.isThresholdMeta(meta)) {
+          var element = {
+            position: idx,
+            value: targetIndex
+          };
+          smallValues.push(element);
+          largeValues.push(element);
+          metaToPositionMap.set(meta, idx);
           indices[idx] = {
             meta: meta,
             targetIndex: targetIndex,
@@ -443,11 +337,19 @@ var IntegerBufferSet = /*#__PURE__*/function () {
           };
         }
       }
-      this._onTheFlyIndices = [];
+      this._smallValues = smallValues;
+      this._largeValues = largeValues;
+      this._metaToPositionMap = metaToPositionMap;
+      this._positionToMetaList = indices.map(function (v) {
+        return v == null ? void 0 : v.meta;
+      });
+      this.resetOnTheFlies();
       return indices;
     } catch (err) {
-      this.readyToStartNextLoop();
+      console.log('err ', err);
       return this._positionToMetaList;
+    } finally {
+      this.readyToStartNextLoop();
     }
   };
   _proto._pushToHeaps = function _pushToHeaps(position, value) {
@@ -459,11 +361,26 @@ var IntegerBufferSet = /*#__PURE__*/function () {
     this._largeValues.push(element);
   };
   _proto._setMetaPosition = function _setMetaPosition(meta, position) {
-    var prevMetaOnPosition = this._positionToMetaList[position];
-    if (prevMetaOnPosition) this._metaToPositionMap["delete"](prevMetaOnPosition);
     this._positionToMetaList[position] = meta;
     this._metaToPositionMap.set(meta, position);
   };
+  _proto.commitPosition = function commitPosition(props) {
+    var newIndex = props.newIndex,
+      safeRange = props.safeRange,
+      position = props.position,
+      meta = props.meta;
+    var onTheFlyPositionMeta = this._onTheFlyIndices[position];
+    var positionToReplace = position;
+    if (onTheFlyPositionMeta) {
+      if (onTheFlyPositionMeta === meta) return position;
+      if (this._isOnTheFlyFull) return this.getFliedPosition(newIndex, safeRange);
+      positionToReplace = this._replaceFurthestIndexPosition(newIndex, safeRange);
+      while (this._onTheFlyIndices[positionToReplace]) {
+        positionToReplace = this._replaceFurthestIndexPosition(newIndex, safeRange);
+      }
+    }
+    return positionToReplace;
+  };
   _proto._setMetaIndex = function _setMetaIndex(meta, index) {
     var prevMetaIndex = this.getMetaIndex(meta);
     if (prevMetaIndex !== undefined) {
@@ -483,68 +400,42 @@ var IntegerBufferSet = /*#__PURE__*/function () {
     this._isOnTheFlyFull = false;
   };
   _proto._cleanHeaps = function _cleanHeaps() {
-    this._cleanHeap(this._smallValues);
-    this._cleanHeap(this._largeValues);
+    for (var idx = 0; idx < this._positionToMetaList.length; idx++) {
+      if (this._positionToMetaList[idx] == null) {
+        this._recreateHeaps();
+        return;
+      }
+    }
     var minHeapSize = Math.min(this._smallValues.size(), this._largeValues.size());
     var maxHeapSize = Math.max(this._smallValues.size(), this._largeValues.size());
     if (maxHeapSize > 10 * minHeapSize) {
       this._recreateHeaps();
     }
   };
-  _proto.rebuildHeapsWithValues = function rebuildHeapsWithValues(arr) {
-    var valueToPositionObject = {};
-    var newSmallValues = new Heap([], this._smallerComparator);
-    var newLargeValues = new Heap([], this._greaterComparator);
-    arr.forEach(function (element) {
-      var position = element.position,
-        value = element.value;
-      if (value !== undefined) {
-        var _element2 = {
-          position: position,
-          value: value
-        };
-        newSmallValues.push(_element2);
-        newLargeValues.push(_element2);
-        valueToPositionObject[value] = position;
-      }
-    });
-    var _arr = new Array(this._bufferSize).fill(2);
-    Object.keys(valueToPositionObject).map(function (key) {
-      return _arr[valueToPositionObject[key]] = 1;
-    });
-    _arr.forEach(function (_i, position) {
-      if (_i === 2) {
-        var value = Number.MAX_SAFE_INTEGER - position;
-        var element = {
-          position: position,
-          value: value
-        };
-        newSmallValues.push(element);
-        newLargeValues.push(element);
-        valueToPositionObject[value] = position;
-      }
-    });
-    this._smallValues = newSmallValues;
-    this._largeValues = newLargeValues;
-  };
   _proto._recreateHeaps = function _recreateHeaps() {
-    var sourceHeap = this._smallValues.size() < this._largeValues.size() ? this._smallValues : this._largeValues;
-    var newSmallValues = new Heap([], this._smallerComparator);
-    var newLargeValues = new Heap([], this._greaterComparator);
-    while (!sourceHeap.empty()) {
-      var element = sourceHeap.pop();
-      if (this._metaToPositionMap.get(this._indexToMetaMap.get(element.value)) != null) {
-        newSmallValues.push(element);
-        newLargeValues.push(element);
+    var _this$initialize2 = this.initialize(),
+      smallValues = _this$initialize2.smallValues,
+      largeValues = _this$initialize2.largeValues;
+    for (var position = 0; position < this._positionToMetaList.length; position++) {
+      var meta = this._positionToMetaList[position];
+      var value = this.getMetaIndex(meta);
+      if (!meta || value === -1 || value == null) {
+        value = Number.MAX_SAFE_INTEGER - position;
+      }
+      var element = {
+        position: position,
+        value: value
+      };
+      smallValues.push(element);
+      largeValues.push(element);
+      if (value > thresholdNumber) {
+        this._setMetaPosition(value, position);
+        this._setMetaIndex(value, value);
       }
     }
-    this._smallValues = newSmallValues;
-    this._largeValues = newLargeValues;
-  };
-  _proto._cleanHeap = function _cleanHeap(heap) {
-    while (!heap.empty() && this._metaToPositionMap.get(this._indexToMetaMap.get(heap.peek().value)) == null) {
-      heap.pop();
-    }
+    this._largeValues.peek().value;
+    this._smallValues = smallValues;
+    this._largeValues = largeValues;
   };
   _proto._smallerComparator = function _smallerComparator(lhs, rhs) {
     return lhs.value < rhs.value;