@tstdl/base 0.87.13 → 0.88.0-alpha1

package/utils/encoding.js

@@ -1,68 +1,70 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var encoding_exports = {};
-__export(encoding_exports, {
-  decodeHex: () => decodeHex,
-  decodeText: () => decodeText,
-  decodeTextStream: () => decodeTextStream,
-  encodeHex: () => encodeHex,
-  encodeUtf8: () => encodeUtf8,
-  encodeUtf8Stream: () => encodeUtf8Stream
-});
-module.exports = __toCommonJS(encoding_exports);
-var import_assertion_error = require("../error/assertion.error.js");
-var import_array = require("./array/array.js");
-var import_binary = require("./binary.js");
-var import_type_guards = require("./type-guards.js");
-const byteToHex = (0, import_array.createArray)(2 ** 8, (i) => i).map((value) => value.toString(16).padStart(2, "0"));
+import { AssertionError } from '../error/assertion.error.js';
+import { createArray } from './array/array.js';
+import { toUint8Array } from './binary.js';
+import { isUndefined } from './type-guards.js';
+const byteToHex = createArray(2 ** 8, (i) => i).map((value) => value.toString(16).padStart(2, '0'));
 const hexToByte = new Map(byteToHex.map((hex, value) => [hex, value]));
-function encodeUtf8(text) {
-  const encoder = new TextEncoder();
-  return encoder.encode(text);
+/**
+ * encodes text to utf8
+ * @param text text to encode
+ * @returns utf8 encoded text
+ */
+export function encodeUtf8(text) {
+    const encoder = new TextEncoder();
+    return encoder.encode(text);
 }
-function encodeUtf8Stream() {
-  return new TextEncoderStream();
+/**
+ * encodes text stream to utf8 bytes stream
+ */
+export function encodeUtf8Stream() {
+    return new TextEncoderStream();
 }
-function decodeText(buffer, encoding) {
-  const decoder = new TextDecoder(encoding, { fatal: true });
-  return decoder.decode(buffer);
+/**
+ * decodes buffer to string
+ * @param buffer buffer to decode
+ * @param encoding encoding, defaults to utf8
+ * @returns decoded string
+ */
+export function decodeText(buffer, encoding) {
+    const decoder = new TextDecoder(encoding, { fatal: true });
+    return decoder.decode(buffer);
 }
-function decodeTextStream(encoding) {
-  return new TextDecoderStream(encoding, { fatal: true });
+/**
+ * transforms binary stream to string stream
+ * @param encoding encoding, defaults to utf8
+ * @returns stream of decoded string
+ */
+export function decodeTextStream(encoding) {
+    return new TextDecoderStream(encoding, { fatal: true });
 }
-function encodeHex(buffer) {
-  const bytes = (0, import_binary.toUint8Array)(buffer);
-  let result = "";
-  for (let i = 0; i < bytes.length; i++) {
-    result += byteToHex[bytes[i]];
-  }
-  return result;
+/**
+ * encodes buffer to hex
+ * @param buffer buffer to encode
+ * @returns hex encoded string
+ */
+export function encodeHex(buffer) {
+    const bytes = toUint8Array(buffer);
+    let result = '';
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let i = 0; i < bytes.length; i++) {
+        result += byteToHex[bytes[i]];
+    }
+    return result;
 }
-function decodeHex(hex) {
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    const hexPart = hex.substring(i, i + 2);
-    const byte = hexToByte.get(hexPart);
-    if ((0, import_type_guards.isUndefined)(byte)) {
-      throw new import_assertion_error.AssertionError(`invalid hex string at position ${i}`);
+/**
+ * decodes hex string to buffer
+ * @param hex hex string to decode
+ * @returns decoded buffer
+ */
+export function decodeHex(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        const hexPart = hex.substring(i, i + 2);
+        const byte = hexToByte.get(hexPart);
+        if (isUndefined(byte)) {
+            throw new AssertionError(`invalid hex string at position ${i}`);
+        }
+        bytes[i / 2] = byte;
     }
-    bytes[i / 2] = byte;
-  }
-  return bytes;
+    return bytes;
 }

package/utils/enum.js

@@ -1,60 +1,34 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var enum_exports = {};
-__export(enum_exports, {
-  enumEntries: () => enumEntries,
-  enumKeys: () => enumKeys,
-  enumValueName: () => enumValueName,
-  enumValues: () => enumValues,
-  randomEnumValue: () => randomEnumValue
-});
-module.exports = __toCommonJS(enum_exports);
-var import_array = require("./array/array.js");
-var import_memoize = require("./function/memoize.js");
-var import_object = require("./object/object.js");
-var import_type_guards = require("./type-guards.js");
-const memoizedEnumEntries = (0, import_memoize.memoizeSingle)(_enumEntries, { weak: true });
-const memoizedEnumKeys = (0, import_memoize.memoizeSingle)(_enumKeys, { weak: true });
-const memoizedEnumValues = (0, import_memoize.memoizeSingle)(_enumValues, { weak: true });
-function enumValueName(enumeration, value) {
-  return (0, import_type_guards.isNumber)(value) ? enumeration[value]?.toString() ?? value.toString() : value;
-}
-function enumEntries(enumeration) {
-  return memoizedEnumEntries(enumeration);
-}
-function enumKeys(enumeration) {
-  return memoizedEnumKeys(enumeration);
-}
-function enumValues(enumeration) {
-  return memoizedEnumValues(enumeration);
-}
-function randomEnumValue(enumeration) {
-  return (0, import_array.randomItem)(enumValues(enumeration));
+import { randomItem } from './array/array.js';
+import { memoizeSingle } from './function/memoize.js';
+import { objectEntries } from './object/object.js';
+import { isNumber } from './type-guards.js';
+const memoizedEnumEntries = memoizeSingle(_enumEntries, { weak: true });
+const memoizedEnumKeys = memoizeSingle(_enumKeys, { weak: true });
+const memoizedEnumValues = memoizeSingle(_enumValues, { weak: true });
+export function enumValueName(enumeration, value) {
+    return isNumber(value) ? enumeration[value]?.toString() ?? value.toString() : value;
+}
+export function enumEntries(enumeration) {
+    return memoizedEnumEntries(enumeration);
+}
+export function enumKeys(enumeration) {
+    return memoizedEnumKeys(enumeration);
+}
+export function enumValues(enumeration) {
+    return memoizedEnumValues(enumeration);
+}
+export function randomEnumValue(enumeration) {
+    return randomItem(enumValues(enumeration));
 }
 function _enumEntries(enumeration) {
-  return (0, import_object.objectEntries)(enumeration).filter((entry) => Number.isNaN(Number(entry[0])));
+    return objectEntries(enumeration)
+        .filter((entry) => Number.isNaN(Number(entry[0])));
 }
 function _enumKeys(enumeration) {
-  const entries = enumEntries(enumeration);
-  return entries.map((entry) => entry[0]);
+    const entries = enumEntries(enumeration);
+    return entries.map((entry) => entry[0]);
 }
 function _enumValues(enumeration) {
-  const entries = enumEntries(enumeration);
-  return entries.map((entry) => entry[1]);
+    const entries = enumEntries(enumeration);
+    return entries.map((entry) => entry[1]);
 }

package/utils/equals.js

@@ -1,131 +1,115 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+/* eslint-disable @typescript-eslint/ban-types */
+import { toArray } from './array/array.js';
+import { toUint8Array } from './binary.js';
+import { compareByValue } from './comparison.js';
+import { sort } from './iterable-helpers/sort.js';
+import { isDefined, isNotNull, isNull } from './type-guards.js';
+const equalsSymbol = Symbol('equals');
+// eslint-disable-next-line @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention
+export const Equals = {
+    symbol: equalsSymbol
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var equals_exports = {};
-__export(equals_exports, {
-  Equals: () => Equals,
-  arrayEquals: () => arrayEquals,
-  binaryEquals: () => binaryEquals,
-  equals: () => equals,
-  strictEquals: () => strictEquals
-});
-module.exports = __toCommonJS(equals_exports);
-var import_array = require("./array/array.js");
-var import_binary = require("./binary.js");
-var import_comparison = require("./comparison.js");
-var import_sort = require("./iterable-helpers/sort.js");
-var import_type_guards = require("./type-guards.js");
-const equalsSymbol = Symbol("equals");
-const Equals = {
-  symbol: equalsSymbol
-};
-function strictEquals(a, b) {
-  return a === b;
+export function strictEquals(a, b) {
+    return a === b;
 }
-function arrayEquals(a, b, options) {
-  const _sort = options?.sort ?? false;
-  const comparator = options?.comparator ?? equals;
-  if (a.length != b.length) {
-    return false;
-  }
-  const c = _sort != false ? (0, import_array.toArray)((0, import_sort.sort)(a, _sort)) : a;
-  const d = _sort != false ? (0, import_array.toArray)((0, import_sort.sort)(b, _sort)) : b;
-  for (let i = 0; i < c.length; i++) {
-    const itemEquals = comparator(c[i], d[i]);
-    if (!itemEquals) {
-      return false;
+export function arrayEquals(a, b, options) {
+    const _sort = options?.sort ?? false;
+    const comparator = options?.comparator ?? equals;
+    if (a.length != b.length) {
+        return false;
     }
-  }
-  return true;
-}
-const allowedEqualsCoerceStringsTypes = ["string", "number", "boolean", "bigint"];
-function equals(a, b, options = {}, visitedNodes = /* @__PURE__ */ new Set()) {
-  if (a === b) {
-    return true;
-  }
-  const aType = typeof a;
-  const bType = typeof b;
-  if (aType != bType) {
-    if ((0, import_type_guards.isDefined)(options.coerceStrings) && allowedEqualsCoerceStringsTypes.includes(aType) && allowedEqualsCoerceStringsTypes.includes(bType)) {
-      return a.toString() == b.toString();
+    const c = _sort != false ? toArray(sort(a, _sort)) : a;
+    const d = _sort != false ? toArray(sort(b, _sort)) : b;
+    for (let i = 0; i < c.length; i++) {
+        const itemEquals = comparator(c[i], d[i]);
+        if (!itemEquals) {
+            return false;
+        }
     }
-    return false;
-  }
-  switch (aType) {
-    case "function":
-      return options.deep == true ? a.toString() == b.toString() : false;
-    case "object":
-      if ((0, import_type_guards.isNull)(a) || (0, import_type_guards.isNull)(b)) {
-        return false;
-      }
-      if (visitedNodes.has(a)) {
+    return true;
+}
+const allowedEqualsCoerceStringsTypes = ['string', 'number', 'boolean', 'bigint'];
+export function equals(a, b, options = {}, visitedNodes = new Set()) {
+    if (a === b) {
         return true;
-      }
-      visitedNodes.add(a);
-      const aPrototype = Object.getPrototypeOf(a);
-      const bPrototype = Object.getPrototypeOf(b);
-      if (aPrototype !== bPrototype) {
-        return false;
-      }
-      if (Array.isArray(a)) {
-        return options.arrayDeep != false && (options.deep == true || options.arrayDeep == true) ? arrayEquals(a, b, { sort: options.sortArray == true ? import_comparison.compareByValue : void 0, comparator: (x, y) => equals(x, y, options, visitedNodes) }) : a === b;
-      }
-      if (Equals.symbol in a) {
-        return a[Equals.symbol](b);
-      }
-      if (Equals.symbol in b) {
-        return b[Equals.symbol](a);
-      }
-      if (aPrototype != Object.prototype && (0, import_type_guards.isNotNull)(aPrototype)) {
-        throw new Error("Equals only supports literal objects, arrays, primitives and Equals interface implementations.");
-      }
-      if (options.deep == false) {
+    }
+    const aType = typeof a;
+    const bType = typeof b;
+    if (aType != bType) {
+        if (isDefined(options.coerceStrings) && allowedEqualsCoerceStringsTypes.includes(aType) && allowedEqualsCoerceStringsTypes.includes(bType)) {
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            return a.toString() == b.toString();
+        }
         return false;
-      }
-      return objectEquals(a, b, options, visitedNodes);
-    default:
-      return a === b;
-  }
+    }
+    switch (aType) {
+        case 'function':
+            return (options.deep == true)
+                ? a.toString() == b.toString()
+                : false;
+        case 'object':
+            if (isNull(a) || isNull(b)) { // hasn't passed equals check at top, so one must be a true object
+                return false;
+            }
+            if (visitedNodes.has(a)) {
+                return true;
+            }
+            visitedNodes.add(a);
+            const aPrototype = Object.getPrototypeOf(a);
+            const bPrototype = Object.getPrototypeOf(b);
+            if (aPrototype !== bPrototype) {
+                return false;
+            }
+            if (Array.isArray(a)) {
+                return (options.arrayDeep != false && (options.deep == true || options.arrayDeep == true))
+                    ? arrayEquals(a, b, { sort: (options.sortArray == true) ? compareByValue : undefined, comparator: (x, y) => equals(x, y, options, visitedNodes) })
+                    : a === b;
+            }
+            if (Equals.symbol in a) {
+                return a[Equals.symbol](b);
+            }
+            if (Equals.symbol in b) {
+                return b[Equals.symbol](a);
+            }
+            if ((aPrototype != Object.prototype) && isNotNull(aPrototype)) { // checking a is enough, because b must have equal prototype (checked above)
+                throw new Error('Equals only supports literal objects, arrays, primitives and Equals interface implementations.');
+            }
+            if (options.deep == false) {
+                return false;
+            }
+            return objectEquals(a, b, options, visitedNodes);
+        default:
+            return a === b;
+    }
 }
+// eslint-disable-next-line max-statements, max-lines-per-function
 function objectEquals(a, b, options, visitedNodes) {
-  const aProperties = Object.getOwnPropertyNames(a);
-  const bProperties = Object.getOwnPropertyNames(b);
-  if (!arrayEquals(aProperties, bProperties, { sort: import_comparison.compareByValue })) {
-    return false;
-  }
-  for (const property of aProperties) {
-    const eq = equals(a[property], b[property], options, visitedNodes);
-    if (!eq) {
-      return false;
+    const aProperties = Object.getOwnPropertyNames(a);
+    const bProperties = Object.getOwnPropertyNames(b);
+    if (!arrayEquals(aProperties, bProperties, { sort: compareByValue })) {
+        return false;
+    }
+    for (const property of aProperties) {
+        const eq = equals(a[property], b[property], options, visitedNodes);
+        if (!eq) {
+            return false;
+        }
     }
-  }
-  return true;
+    return true;
 }
-function binaryEquals(bufferA, bufferB) {
-  const a = (0, import_binary.toUint8Array)(bufferA, false);
-  const b = (0, import_binary.toUint8Array)(bufferB, false);
-  if (a.length != b.length) {
-    return false;
-  }
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] != b[i]) {
-      return false;
+/**
+ * compares to binary types for equal content
+ */
+export function binaryEquals(bufferA, bufferB) {
+    const a = toUint8Array(bufferA, false);
+    const b = toUint8Array(bufferB, false);
+    if (a.length != b.length) {
+        return false;
     }
-  }
-  return true;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] != b[i]) {
+            return false;
+        }
+    }
+    return true;
 }

package/utils/event-loop.js

@@ -1,42 +1,22 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var event_loop_exports = {};
-__export(event_loop_exports, {
-  measureEventLoopDelay: () => measureEventLoopDelay,
-  runEventLoopWatcher: () => runEventLoopWatcher
-});
-module.exports = __toCommonJS(event_loop_exports);
-var import_format = require("./format.js");
-var import_periodic_sampler = require("./periodic-sampler.js");
-var import_timer = require("./timer.js");
-async function measureEventLoopDelay() {
-  return new Promise((resolve) => {
-    const stopwatch = new import_timer.Timer();
-    setImmediate(() => {
-      stopwatch.start();
-      setImmediate(() => resolve(stopwatch.milliseconds));
+import { formatDuration } from './format.js';
+import { AggregationMode, PeriodicSampler } from './periodic-sampler.js';
+import { Timer } from './timer.js';
+export async function measureEventLoopDelay() {
+    return new Promise((resolve) => {
+        const stopwatch = new Timer();
+        setImmediate(() => {
+            stopwatch.start();
+            // inner setImmediate, to measure an full event-loop-cycle
+            setImmediate(() => resolve(stopwatch.milliseconds));
+        });
     });
-  });
 }
-function runEventLoopWatcher(logger, cancellationSignal) {
-  const sampler = new import_periodic_sampler.PeriodicSampler(measureEventLoopDelay, 50);
-  sampler.watch(0, 100, import_periodic_sampler.AggregationMode.ThirdQuartile).subscribe((delay) => logger.debug(`eventloop: ${(0, import_format.formatDuration)(delay, 2)}`));
-  sampler.start();
-  cancellationSignal.then(async () => sampler.stop());
+export function runEventLoopWatcher(logger, cancellationSignal) {
+    const sampler = new PeriodicSampler(measureEventLoopDelay, 50);
+    sampler
+        .watch(0, 100, AggregationMode.ThirdQuartile)
+        .subscribe((delay) => logger.debug(`eventloop: ${formatDuration(delay, 2)}`));
+    sampler.start();
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    cancellationSignal.then(async () => sampler.stop());
 }

package/utils/factory-map.js

@@ -1,77 +1,55 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var factory_map_exports = {};
-__export(factory_map_exports, {
-  FactoryMap: () => FactoryMap
-});
-module.exports = __toCommonJS(factory_map_exports);
-class FactoryMap {
-  factory;
-  [Symbol.toStringTag];
-  backingMap;
-  get size() {
-    return this.backingMap.size;
-  }
-  constructor(factory, backingMap) {
-    this.factory = factory;
-    this[Symbol.toStringTag] = "FactoryMap";
-    this.backingMap = backingMap ?? /* @__PURE__ */ new Map();
-  }
-  clear() {
-    this.backingMap.clear();
-  }
-  has(key) {
-    return this.backingMap.has(key);
-  }
-  get(key) {
-    const has = this.backingMap.has(key);
-    if (has) {
-      return this.backingMap.get(key);
+/** same as {@link Map}, except that it will build the value with the provided factory on {@link get} if it doesnt exist */
+export class FactoryMap {
+    factory;
+    [Symbol.toStringTag];
+    backingMap;
+    get size() {
+        return this.backingMap.size;
+    }
+    constructor(factory, backingMap) {
+        this.factory = factory;
+        this[Symbol.toStringTag] = 'FactoryMap';
+        this.backingMap = backingMap ?? new Map();
+    }
+    clear() {
+        this.backingMap.clear();
+    }
+    has(key) {
+        return this.backingMap.has(key);
+    }
+    get(key) {
+        const has = this.backingMap.has(key);
+        if (has) {
+            return this.backingMap.get(key);
+        }
+        const value = this.factory(key);
+        this.backingMap.set(key, value);
+        return value;
+    }
+    getWithoutBuild(key) {
+        return this.backingMap.get(key);
+    }
+    set(key, value) {
+        this.backingMap.set(key, value);
+        return this;
+    }
+    delete(key) {
+        return this.backingMap.delete(key);
+    }
+    forEach(callback, thisArg) {
+        const boundCallback = callback.bind(thisArg);
+        this.backingMap.forEach((value, key) => boundCallback(value, key, this));
+    }
+    *[Symbol.iterator]() {
+        yield* this.backingMap[Symbol.iterator]();
+    }
+    *entries() {
+        yield* this.backingMap.entries();
+    }
+    *keys() {
+        yield* this.backingMap.keys();
+    }
+    *values() {
+        yield* this.backingMap.values();
     }
-    const value = this.factory(key);
-    this.backingMap.set(key, value);
-    return value;
-  }
-  getWithoutBuild(key) {
-    return this.backingMap.get(key);
-  }
-  set(key, value) {
-    this.backingMap.set(key, value);
-    return this;
-  }
-  delete(key) {
-    return this.backingMap.delete(key);
-  }
-  forEach(callback, thisArg) {
-    const boundCallback = callback.bind(thisArg);
-    this.backingMap.forEach((value, key) => boundCallback(value, key, this));
-  }
-  *[Symbol.iterator]() {
-    yield* this.backingMap[Symbol.iterator]();
-  }
-  *entries() {
-    yield* this.backingMap.entries();
-  }
-  *keys() {
-    yield* this.backingMap.keys();
-  }
-  *values() {
-    yield* this.backingMap.values();
-  }
 }