@tstdl/base 0.86.0-beta1 → 0.86.0-beta11

package/utils/encoding.js

@@ -1,70 +1,68 @@
-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'));
+"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"));
 const hexToByte = new Map(byteToHex.map((hex, value) => [hex, value]));
-/**
- * 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 encodeUtf8(text) {
+  const encoder = new TextEncoder();
+  return encoder.encode(text);
 }
-/**
- * encodes text stream to utf8 bytes stream
- */
-export function encodeUtf8Stream() {
-    return new TextEncoderStream();
+function encodeUtf8Stream() {
+  return new TextEncoderStream();
 }
-/**
- * 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 decodeText(buffer, encoding) {
+  const decoder = new TextDecoder(encoding, { fatal: true });
+  return decoder.decode(buffer);
 }
-/**
- * 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 decodeTextStream(encoding) {
+  return new TextDecoderStream(encoding, { fatal: true });
 }
-/**
- * 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 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;
 }
-/**
- * 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;
+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}`);
     }
-    return bytes;
+    bytes[i / 2] = byte;
+  }
+  return bytes;
 }

package/utils/enum.js

@@ -1,34 +1,60 @@
-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));
+"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));
 }
 function _enumEntries(enumeration) {
-    return objectEntries(enumeration)
-        .filter((entry) => Number.isNaN(Number(entry[0])));
+  return (0, import_object.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,115 +1,131 @@
-/* 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
+"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 });
 };
-export function strictEquals(a, b) {
-    return a === b;
+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 arrayEquals(a, b, options) {
-    const _sort = options?.sort ?? false;
-    const comparator = options?.comparator ?? equals;
-    if (a.length != b.length) {
-        return false;
+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;
     }
-    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 true;
+  }
+  return true;
 }
-const allowedEqualsCoerceStringsTypes = ['string', 'number', 'boolean', 'bigint'];
-export function equals(a, b, options = {}, visitedNodes = new Set()) {
-    if (a === b) {
-        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 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;
+  }
+  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;
-    }
-    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;
-    }
+      }
+      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 ? 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) {
+        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: 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: import_comparison.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;
 }
-/**
- * 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;
+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;
     }
-    for (let i = 0; i < a.length; i++) {
-        if (a[i] != b[i]) {
-            return false;
-        }
-    }
-    return true;
+  }
+  return true;
 }

package/utils/event-loop.js

@@ -1,22 +1,42 @@
-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));
-        });
+"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));
     });
+  });
 }
-export function runEventLoopWatcher(logger, cancellationToken) {
-    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
-    cancellationToken.then(async () => sampler.stop());
+function runEventLoopWatcher(logger, cancellationToken) {
+  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();
+  cancellationToken.then(async () => sampler.stop());
 }

package/utils/factory-map.js

@@ -1,55 +1,77 @@
-/** 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();
+"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);
     }
+    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();
+  }
 }