serializable-bptree 3.2.3 → 3.2.4

package/dist/cjs/index.js

@@ -61,19 +61,374 @@ var StringComparator = class extends ValueComparator {
   }
 };
 
-// src/utils/CacheStorage.ts
-var CacheStorage = class extends Map {
+// node_modules/cachebranch/dist/esm/index.js
+var CacheBranch = class {
+  data;
+  branches;
+  constructor(data) {
+    this.data = data;
+    this.branches = /* @__PURE__ */ new Map();
+  }
+  /**
+   * The method splits the provided key value into tokens and returns them as an array.
+   * For instance, if you pass `'user/name/middle'` as the parameter, it will return `['user', 'name', 'middle']` as the split values.
+   * @param key The key value to split.
+   */
+  tokens(key) {
+    return key.split("/");
+  }
+  to(key, getNextBranch) {
+    const tokens = this.tokens(key);
+    let current = this;
+    for (let i = 0, len = tokens.length; i < len; i++) {
+      const last = i === len - 1;
+      const key2 = tokens[i];
+      const next = getNextBranch(current, key2, i, last);
+      if (next === null) {
+        return void 0;
+      }
+      current = next;
+    }
+    return current;
+  }
+};
+var VOID = -1;
+var PRIMITIVE = 0;
+var ARRAY = 1;
+var OBJECT = 2;
+var DATE = 3;
+var REGEXP = 4;
+var MAP = 5;
+var SET = 6;
+var ERROR = 7;
+var BIGINT = 8;
+var env = typeof self === "object" ? self : globalThis;
+var deserializer = ($, _) => {
+  const as = (out, index) => {
+    $.set(index, out);
+    return out;
+  };
+  const unpair = (index) => {
+    if ($.has(index))
+      return $.get(index);
+    const [type, value] = _[index];
+    switch (type) {
+      case PRIMITIVE:
+      case VOID:
+        return as(value, index);
+      case ARRAY: {
+        const arr = as([], index);
+        for (const index2 of value)
+          arr.push(unpair(index2));
+        return arr;
+      }
+      case OBJECT: {
+        const object = as({}, index);
+        for (const [key, index2] of value)
+          object[unpair(key)] = unpair(index2);
+        return object;
+      }
+      case DATE:
+        return as(new Date(value), index);
+      case REGEXP: {
+        const { source, flags } = value;
+        return as(new RegExp(source, flags), index);
+      }
+      case MAP: {
+        const map = as(/* @__PURE__ */ new Map(), index);
+        for (const [key, index2] of value)
+          map.set(unpair(key), unpair(index2));
+        return map;
+      }
+      case SET: {
+        const set = as(/* @__PURE__ */ new Set(), index);
+        for (const index2 of value)
+          set.add(unpair(index2));
+        return set;
+      }
+      case ERROR: {
+        const { name, message } = value;
+        return as(new env[name](message), index);
+      }
+      case BIGINT:
+        return as(BigInt(value), index);
+      case "BigInt":
+        return as(Object(BigInt(value)), index);
+    }
+    return as(new env[type](value), index);
+  };
+  return unpair;
+};
+var deserialize = (serialized) => deserializer(/* @__PURE__ */ new Map(), serialized)(0);
+var EMPTY = "";
+var { toString } = {};
+var { keys } = Object;
+var typeOf = (value) => {
+  const type = typeof value;
+  if (type !== "object" || !value)
+    return [PRIMITIVE, type];
+  const asString = toString.call(value).slice(8, -1);
+  switch (asString) {
+    case "Array":
+      return [ARRAY, EMPTY];
+    case "Object":
+      return [OBJECT, EMPTY];
+    case "Date":
+      return [DATE, EMPTY];
+    case "RegExp":
+      return [REGEXP, EMPTY];
+    case "Map":
+      return [MAP, EMPTY];
+    case "Set":
+      return [SET, EMPTY];
+  }
+  if (asString.includes("Array"))
+    return [ARRAY, asString];
+  if (asString.includes("Error"))
+    return [ERROR, asString];
+  return [OBJECT, asString];
+};
+var shouldSkip = ([TYPE, type]) => TYPE === PRIMITIVE && (type === "function" || type === "symbol");
+var serializer = (strict, json, $, _) => {
+  const as = (out, value) => {
+    const index = _.push(out) - 1;
+    $.set(value, index);
+    return index;
+  };
+  const pair = (value) => {
+    if ($.has(value))
+      return $.get(value);
+    let [TYPE, type] = typeOf(value);
+    switch (TYPE) {
+      case PRIMITIVE: {
+        let entry = value;
+        switch (type) {
+          case "bigint":
+            TYPE = BIGINT;
+            entry = value.toString();
+            break;
+          case "function":
+          case "symbol":
+            if (strict)
+              throw new TypeError("unable to serialize " + type);
+            entry = null;
+            break;
+          case "undefined":
+            return as([VOID], value);
+        }
+        return as([TYPE, entry], value);
+      }
+      case ARRAY: {
+        if (type)
+          return as([type, [...value]], value);
+        const arr = [];
+        const index = as([TYPE, arr], value);
+        for (const entry of value)
+          arr.push(pair(entry));
+        return index;
+      }
+      case OBJECT: {
+        if (type) {
+          switch (type) {
+            case "BigInt":
+              return as([type, value.toString()], value);
+            case "Boolean":
+            case "Number":
+            case "String":
+              return as([type, value.valueOf()], value);
+          }
+        }
+        if (json && "toJSON" in value)
+          return pair(value.toJSON());
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const key of keys(value)) {
+          if (strict || !shouldSkip(typeOf(value[key])))
+            entries.push([pair(key), pair(value[key])]);
+        }
+        return index;
+      }
+      case DATE:
+        return as([TYPE, value.toISOString()], value);
+      case REGEXP: {
+        const { source, flags } = value;
+        return as([TYPE, { source, flags }], value);
+      }
+      case MAP: {
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const [key, entry] of value) {
+          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))
+            entries.push([pair(key), pair(entry)]);
+        }
+        return index;
+      }
+      case SET: {
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const entry of value) {
+          if (strict || !shouldSkip(typeOf(entry)))
+            entries.push(pair(entry));
+        }
+        return index;
+      }
+    }
+    const { message } = value;
+    return as([TYPE, { name: type, message }], value);
+  };
+  return pair;
+};
+var serialize = (value, { json, lossy } = {}) => {
+  const _ = [];
+  return serializer(!(json || lossy), !!json, /* @__PURE__ */ new Map(), _)(value), _;
+};
+var esm_default = typeof structuredClone === "function" ? (
+  /* c8 ignore start */
+  (any, options) => options && ("json" in options || "lossy" in options) ? deserialize(serialize(any, options)) : structuredClone(any)
+) : (any, options) => deserialize(serialize(any, options));
+var CacheData = class _CacheData {
+  static IsDirty(data) {
+    return data.dirty;
+  }
+  static SetDirty(data, value) {
+    data.dirty = value;
+    return data;
+  }
+  static StructuredClone = globalThis.structuredClone ?? esm_default;
+  _raw;
+  generator;
+  dirty;
+  constructor(generator) {
+    this._raw = void 0;
+    this.dirty = false;
+    this.generator = generator;
+  }
+  /**
+   * This is cached data.
+   * It was generated at the time of caching, so there is a risk of modification if it's an object due to shallow copying.
+   * Therefore, if it's not a primitive type, please avoid using this value directly and use the `clone` method to use a copied version of the data.
+   */
+  get raw() {
+    if (!this.dirty) {
+      throw new Error(`The data is not initialized and cannot be accessed. Please use the 'ensure' or 'set' method to create the data first.`);
+    }
+    return this._raw;
+  }
+  /**
+   * The method returns a copied value of the cached data.
+   * You can pass a function as a parameter to copy the value. This parameter function should return the copied value.
+   * 
+   * If no parameter is passed, it defaults to using Javascript's or \@ungap/structured-clone's `structuredClone` function to copy the value.
+   * If you prefer shallow copying instead of deep copying,
+   * you can use the default options `array-shallow-copy`, `object-shallow-copy` and `deep-copy`,
+   * which are replaced with functions to shallow copy arrays and objects, respectively. This is a syntactic sugar.
+   * @param strategy The function that returns the copied value.
+   * If you want to perform a shallow copy, simply pass the strings `array-shallow-copy` or `object-shallow-copy` for easy use.
+   * The default is `structuredClone`.
+   */
+  clone(strategy = "deep-copy") {
+    if (strategy && typeof strategy !== "string") {
+      return strategy(this.raw);
+    }
+    switch (strategy) {
+      case "array-shallow-copy":
+        return [].concat(this.raw);
+      case "object-shallow-copy":
+        return Object.assign({}, this.raw);
+      case "deep-copy":
+      default:
+        return _CacheData.StructuredClone(this.raw);
+    }
+  }
+};
+var CacheDataSync = class extends CacheData {
+  static EmptyDataGenerator = () => void 0;
+  static Update(branch, data, generator) {
+    data._raw = generator(branch);
+    data.generator = generator;
+    data.dirty = true;
+    return data;
+  }
+  static Cache(branch, data) {
+    data._raw = data.generator(branch);
+    return data;
+  }
+};
+var CacheBranchSync = class _CacheBranchSync extends CacheBranch {
+  root;
+  constructor(generator = CacheDataSync.EmptyDataGenerator, root) {
+    super(new CacheDataSync(generator));
+    this.root = root ?? this;
+  }
+  ensureBranch(key, generator) {
+    return this.to(key, (b, k) => {
+      const branch = b;
+      if (!branch.branches.has(k)) {
+        branch.branches.set(k, new _CacheBranchSync(generator, this.root));
+      }
+      return branch.branches.get(k);
+    });
+  }
+  getBranch(key) {
+    return this.to(key, (b, k) => {
+      const branch = b;
+      if (!branch.branches.has(k)) {
+        return null;
+      }
+      return branch.branches.get(k);
+    });
+  }
+  cache(key, recursive) {
+    const branch = this.ensureBranch(key, CacheDataSync.EmptyDataGenerator);
+    if (!branch) {
+      return this;
+    }
+    if (recursive === "bottom-up") {
+      for (const key2 of branch.branches.keys()) {
+        branch.cache(key2, recursive);
+      }
+    }
+    CacheDataSync.Cache(this.root, branch.data);
+    if (recursive === "top-down") {
+      for (const key2 of branch.branches.keys()) {
+        branch.cache(key2, recursive);
+      }
+    }
+    return this;
+  }
   ensure(key, generator) {
-    if (!this.has(key)) {
-      this.set(key, generator());
+    const branch = this.ensureBranch(key, CacheDataSync.EmptyDataGenerator);
+    if (!CacheDataSync.IsDirty(branch.data)) {
+      CacheDataSync.Update(this.root, branch.data, generator);
+    }
+    return branch.data;
+  }
+  get(key) {
+    const branch = this.ensureBranch(key, CacheDataSync.EmptyDataGenerator);
+    if (!CacheDataSync.IsDirty(branch.data)) {
+      return void 0;
+    }
+    return branch.data;
+  }
+  set(key, generator) {
+    const branch = this.ensureBranch(key, CacheDataSync.EmptyDataGenerator);
+    CacheDataSync.Update(this.root, branch.data, generator);
+    return this;
+  }
+  delete(key) {
+    const branch = this.ensureBranch(key, CacheDataSync.EmptyDataGenerator);
+    if (branch) {
+      branch.branches.clear();
+      CacheDataSync.Update(this.root, branch.data, CacheDataSync.EmptyDataGenerator);
+      CacheDataSync.SetDirty(branch.data, false);
     }
-    return this.get(key);
+    return this;
   }
 };
 
 // src/base/BPTree.ts
 var BPTree = class {
-  _regexpCache;
+  _cachedRegexp;
   strategy;
   comparator;
   nodes;
@@ -91,10 +446,10 @@ var BPTree = class {
     like: (nv, v) => {
       const nodeValue = this.comparator.match(nv);
       const value = this.comparator.match(v);
-      const regexp = this._regexpCache.ensure(value, () => {
+      const regexp = this._cachedRegexp.ensure(value, () => {
         const pattern = value.replace(/%/g, ".*").replace(/_/g, ".");
         return new RegExp(`^${pattern}$`, "i");
-      });
+      }).raw;
       return regexp.test(nodeValue);
     }
   };
@@ -126,7 +481,7 @@ var BPTree = class {
     like: true
   };
   constructor(strategy, comparator) {
-    this._regexpCache = new CacheStorage();
+    this._cachedRegexp = new CacheBranchSync();
     this._nodeCreateBuffer = /* @__PURE__ */ new Map();
     this._nodeUpdateBuffer = /* @__PURE__ */ new Map();
     this.nodes = /* @__PURE__ */ new Map();
@@ -138,8 +493,8 @@ var BPTree = class {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         if (this.comparator.isSame(value, nValue)) {
-          const keys = node.keys[i];
-          keys.push(key);
+          const keys2 = node.keys[i];
+          keys2.push(key);
           this.bufferForNodeUpdate(node);
           break;
         } else if (this.comparator.isLower(value, nValue)) {
@@ -190,12 +545,12 @@ var BPTreeSync = class extends BPTree {
       let i = node.values.length;
       while (i--) {
         const nValue = node.values[i];
-        const keys = node.keys[i];
+        const keys2 = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          let j = keys.length;
+          let j = keys2.length;
           while (j--) {
-            pairs.push({ key: keys[j], value: nValue });
+            pairs.push({ key: keys2[j], value: nValue });
           }
         } else if (found && !fullScan) {
           done = true;
@@ -218,10 +573,10 @@ var BPTreeSync = class extends BPTree {
     while (!done) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
-        const keys = node.keys[i];
+        const keys2 = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys) {
+          for (const key of keys2) {
             pairs.push({ key, value: nValue });
           }
         } else if (found && !fullScan) {
@@ -254,11 +609,11 @@ var BPTreeSync = class extends BPTree {
     }
     return id;
   }
-  _createNode(keys, values, leaf = false, parent = 0, next = 0, prev = 0) {
+  _createNode(keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
     const id = this._createNodeId();
     const node = {
       id,
-      keys,
+      keys: keys2,
       values,
       leaf,
       parent,
@@ -288,8 +643,8 @@ var BPTreeSync = class extends BPTree {
       }
     }
     if (this.root === node && node.keys.length === 1) {
-      const keys = node.keys;
-      this.root = this.getNode(keys[0]);
+      const keys2 = node.keys;
+      this.root = this.getNode(keys2[0]);
       this.root.parent = 0;
       this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
@@ -363,8 +718,8 @@ var BPTreeSync = class extends BPTree {
         }
         pointer.values.push(...node.values);
         if (!pointer.leaf) {
-          const keys = pointer.keys;
-          for (const key2 of keys) {
+          const keys2 = pointer.keys;
+          for (const key2 of keys2) {
             const node2 = this.getNode(key2);
             node2.parent = pointer.id;
             this.bufferForNodeUpdate(node2);
@@ -466,33 +821,6 @@ var BPTreeSync = class extends BPTree {
       }
     }
   }
-  _insertAtLeaf(node, key, value) {
-    if (node.values.length) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        if (this.comparator.isSame(value, nValue)) {
-          const keys = node.keys[i];
-          keys.push(key);
-          this.bufferForNodeUpdate(node);
-          break;
-        } else if (this.comparator.isLower(value, nValue)) {
-          node.values.splice(i, 0, value);
-          node.keys.splice(i, 0, [key]);
-          this.bufferForNodeUpdate(node);
-          break;
-        } else if (i + 1 === node.values.length) {
-          node.values.push(value);
-          node.keys.push([key]);
-          this.bufferForNodeUpdate(node);
-          break;
-        }
-      }
-    } else {
-      node.values = [value];
-      node.keys = [[key]];
-      this.bufferForNodeUpdate(node);
-    }
-  }
   _insertInParent(node, value, pointer) {
     if (this.root === node) {
       const root = this._createNode([node.id, pointer.id], [value]);
@@ -590,8 +918,8 @@ var BPTreeSync = class extends BPTree {
   leftestNode() {
     let node = this.root;
     while (!node.leaf) {
-      const keys = node.keys;
-      node = this.getNode(keys[0]);
+      const keys2 = node.keys;
+      node = this.getNode(keys2[0]);
     }
     return node;
   }
@@ -695,17 +1023,17 @@ var BPTreeSync = class extends BPTree {
     while (i--) {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
-        const keys = node.keys[i];
-        if (keys.includes(key)) {
-          if (keys.length > 1) {
-            keys.splice(keys.indexOf(key), 1);
+        const keys2 = node.keys[i];
+        if (keys2.includes(key)) {
+          if (keys2.length > 1) {
+            keys2.splice(keys2.indexOf(key), 1);
             this.bufferForNodeUpdate(node);
           } else if (node === this.root) {
             node.values.splice(i, 1);
             node.keys.splice(i, 1);
             this.bufferForNodeUpdate(node);
           } else {
-            keys.splice(keys.indexOf(key), 1);
+            keys2.splice(keys2.indexOf(key), 1);
             node.keys.splice(i, 1);
             node.values.splice(node.values.indexOf(value), 1);
             this._deleteEntry(node, key, value);
@@ -723,8 +1051,8 @@ var BPTreeSync = class extends BPTree {
     for (let i = 0, len = node.values.length; i < len; i++) {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
-        const keys = node.keys[i];
-        return keys.includes(key);
+        const keys2 = node.keys[i];
+        return keys2.includes(key);
       }
     }
     return false;
@@ -734,13 +1062,13 @@ var BPTreeSync = class extends BPTree {
     this.commitHeadBuffer();
   }
   forceUpdate() {
-    const keys = [...this.nodes.keys()];
+    const keys2 = [...this.nodes.keys()];
     this.nodes.clear();
     this.init();
-    for (const key of keys) {
+    for (const key of keys2) {
       this.getNode(key);
     }
-    return keys.length;
+    return keys2.length;
   }
 };
 
@@ -749,7 +1077,7 @@ var BPTreeAsync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  async _getPairsRightToLeft(value, startNode, fullSearch, comparator) {
+  async _getPairsRightToLeft(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -758,14 +1086,14 @@ var BPTreeAsync = class extends BPTree {
       let i = node.values.length;
       while (i--) {
         const nValue = node.values[i];
-        const keys = node.keys[i];
+        const keys2 = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          let j = keys.length;
+          let j = keys2.length;
           while (j--) {
-            pairs.push({ key: keys[j], value: nValue });
+            pairs.push({ key: keys2[j], value: nValue });
           }
-        } else if (found && !fullSearch) {
+        } else if (found && !fullScan) {
           done = true;
           break;
         }
@@ -778,7 +1106,7 @@ var BPTreeAsync = class extends BPTree {
     }
     return pairs.reverse();
   }
-  async _getPairsLeftToRight(value, startNode, fullSearch, comparator) {
+  async _getPairsLeftToRight(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -786,13 +1114,13 @@ var BPTreeAsync = class extends BPTree {
     while (!done) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
-        const keys = node.keys[i];
+        const keys2 = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys) {
+          for (const key of keys2) {
             pairs.push({ key, value: nValue });
           }
-        } else if (found && !fullSearch) {
+        } else if (found && !fullScan) {
           done = true;
           break;
         }
@@ -805,12 +1133,12 @@ var BPTreeAsync = class extends BPTree {
     }
     return pairs;
   }
-  async getPairs(value, startNode, fullSearch, comparator, direction) {
+  async getPairs(value, startNode, fullScan, comparator, direction) {
     switch (direction) {
       case -1:
-        return await this._getPairsRightToLeft(value, startNode, fullSearch, comparator);
+        return await this._getPairsRightToLeft(value, startNode, fullScan, comparator);
       case 1:
-        return await this._getPairsLeftToRight(value, startNode, fullSearch, comparator);
+        return await this._getPairsLeftToRight(value, startNode, fullScan, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -822,11 +1150,11 @@ var BPTreeAsync = class extends BPTree {
     }
     return id;
   }
-  async _createNode(keys, values, leaf = false, parent = 0, next = 0, prev = 0) {
+  async _createNode(keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
     const id = await this._createNodeId();
     const node = {
       id,
-      keys,
+      keys: keys2,
       values,
       leaf,
       parent,
@@ -856,8 +1184,8 @@ var BPTreeAsync = class extends BPTree {
       }
     }
     if (this.root === node && node.keys.length === 1) {
-      const keys = node.keys;
-      this.root = await this.getNode(keys[0]);
+      const keys2 = node.keys;
+      this.root = await this.getNode(keys2[0]);
       this.root.parent = 0;
       this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
@@ -931,8 +1259,8 @@ var BPTreeAsync = class extends BPTree {
         }
         pointer.values.push(...node.values);
         if (!pointer.leaf) {
-          const keys = pointer.keys;
-          for (const key2 of keys) {
+          const keys2 = pointer.keys;
+          for (const key2 of keys2) {
             const node2 = await this.getNode(key2);
             node2.parent = pointer.id;
             this.bufferForNodeUpdate(node2);
@@ -1131,8 +1459,8 @@ var BPTreeAsync = class extends BPTree {
   async leftestNode() {
     let node = this.root;
     while (!node.leaf) {
-      const keys = node.keys;
-      node = await this.getNode(keys[0]);
+      const keys2 = node.keys;
+      node = await this.getNode(keys2[0]);
     }
     return node;
   }
@@ -1236,17 +1564,17 @@ var BPTreeAsync = class extends BPTree {
     while (i--) {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
-        const keys = node.keys[i];
-        if (keys.includes(key)) {
-          if (keys.length > 1) {
-            keys.splice(keys.indexOf(key), 1);
+        const keys2 = node.keys[i];
+        if (keys2.includes(key)) {
+          if (keys2.length > 1) {
+            keys2.splice(keys2.indexOf(key), 1);
             this.bufferForNodeUpdate(node);
           } else if (node === this.root) {
             node.values.splice(i, 1);
             node.keys.splice(i, 1);
             this.bufferForNodeUpdate(node);
           } else {
-            keys.splice(keys.indexOf(key), 1);
+            keys2.splice(keys2.indexOf(key), 1);
             node.keys.splice(i, 1);
             node.values.splice(node.values.indexOf(value), 1);
             await this._deleteEntry(node, key, value);
@@ -1264,8 +1592,8 @@ var BPTreeAsync = class extends BPTree {
     for (let i = 0, len = node.values.length; i < len; i++) {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
-        const keys = node.keys[i];
-        return keys.includes(key);
+        const keys2 = node.keys[i];
+        return keys2.includes(key);
       }
     }
     return false;
@@ -1275,13 +1603,13 @@ var BPTreeAsync = class extends BPTree {
     await this.commitHeadBuffer();
   }
   async forceUpdate() {
-    const keys = [...this.nodes.keys()];
+    const keys2 = [...this.nodes.keys()];
     this.nodes.clear();
     await this.init();
-    for (const key of keys) {
+    for (const key of keys2) {
       await this.getNode(key);
     }
-    return keys.length;
+    return keys2.length;
   }
 };