@dxos/util 0.8.4-main.c1de068 → 0.8.4-main.dedc0f3

package/dist/lib/browser/index.mjs

@@ -180,31 +180,90 @@ var BitField = class _BitField {
 };
 
 // src/callback-collection.ts
+function _check_private_redeclaration(obj, privateCollection) {
+  if (privateCollection.has(obj)) {
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+  if (descriptor.get) {
+    return descriptor.get.call(receiver);
+  }
+  return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+  if (descriptor.set) {
+    descriptor.set.call(receiver, value);
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+    descriptor.value = value;
+  }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+  if (!privateMap.has(receiver)) {
+    throw new TypeError("attempted to " + action + " private field on non-instance");
+  }
+  return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+  var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+  return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+  _check_private_redeclaration(obj, privateMap);
+  privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+  var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+  _class_apply_descriptor_set(receiver, descriptor, value);
+  return value;
+}
+var _callbacks = /* @__PURE__ */ new WeakMap();
 var CallbackCollection = class {
-  #callbacks = [];
   append(callback) {
-    this.#callbacks.push(callback);
+    _class_private_field_get(this, _callbacks).push(callback);
   }
   prepend(callback) {
-    this.#callbacks.unshift(callback);
+    _class_private_field_get(this, _callbacks).unshift(callback);
   }
   remove(callback) {
-    this.#callbacks = this.#callbacks.filter((c) => c !== callback);
+    _class_private_field_set(this, _callbacks, _class_private_field_get(this, _callbacks).filter((c) => c !== callback));
   }
   callParallel(...args) {
-    return Promise.all(this.#callbacks.map((callback) => callback(...args)));
+    return Promise.all(_class_private_field_get(this, _callbacks).map((callback) => callback(...args)));
   }
   async callSerial(...args) {
     const results = [];
-    for (const callback of this.#callbacks) {
+    for (const callback of _class_private_field_get(this, _callbacks)) {
       results.push(await callback(...args));
     }
     return results;
   }
+  constructor() {
+    _class_private_field_init(this, _callbacks, {
+      writable: true,
+      value: []
+    });
+  }
 };
 
 // src/callback.ts
 import { invariant as invariant2 } from "@dxos/invariant";
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
 var __dxlog_file2 = "/__w/dxos/dxos/packages/common/util/src/callback.ts";
 var Callback = class {
   call(...args) {
@@ -237,6 +296,9 @@ var Callback = class {
   isSet() {
     return !!this._callback;
   }
+  constructor() {
+    _define_property(this, "_callback", void 0);
+  }
 };
 var createSetDispatch = ({ handlers }) => {
   return new Proxy({
@@ -299,22 +361,21 @@ var chunkArray = (array, size) => {
 
 // src/circular-buffer.ts
 import { invariant as invariant3 } from "@dxos/invariant";
-var __dxlog_file3 = "/__w/dxos/dxos/packages/common/util/src/circular-buffer.ts";
-var CircularBuffer = class {
-  constructor(size) {
-    this._nextIndex = 0;
-    this._elementCount = 0;
-    invariant3(size >= 1, void 0, {
-      F: __dxlog_file3,
-      L: 13,
-      S: this,
-      A: [
-        "size >= 1",
-        ""
-      ]
+function _define_property2(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
     });
-    this._buffer = new Array(size);
+  } else {
+    obj[key] = value;
   }
+  return obj;
+}
+var __dxlog_file3 = "/__w/dxos/dxos/packages/common/util/src/circular-buffer.ts";
+var CircularBuffer = class {
   push(element) {
     const evicted = this._elementCount === this._buffer.length ? this._buffer[this._nextIndex] : void 0;
     this._buffer[this._nextIndex] = element;
@@ -354,6 +415,21 @@ var CircularBuffer = class {
       yield this._buffer[i];
     }
   }
+  constructor(size) {
+    _define_property2(this, "_buffer", void 0);
+    _define_property2(this, "_nextIndex", 0);
+    _define_property2(this, "_elementCount", 0);
+    invariant3(size >= 1, void 0, {
+      F: __dxlog_file3,
+      L: 13,
+      S: this,
+      A: [
+        "size >= 1",
+        ""
+      ]
+    });
+    this._buffer = new Array(size);
+  }
 };
 
 // src/clear-undefined.ts
@@ -372,18 +448,22 @@ var clearUndefined = (obj) => {
 // src/complex.ts
 import { inspect } from "@dxos/node-std/util";
 import { inspectObject, raise } from "@dxos/debug";
+function _define_property3(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
 var MAX_SERIALIZATION_LENGTH = 10;
+var _inspect_custom = inspect.custom;
 var ComplexSet = class {
-  // prettier-ignore
-  constructor(_projection, values) {
-    this._projection = _projection;
-    this._values = /* @__PURE__ */ new Map();
-    if (values) {
-      for (const value of values) {
-        this.add(value);
-      }
-    }
-  }
   toString() {
     return inspectObject(this);
   }
@@ -392,7 +472,7 @@ var ComplexSet = class {
       size: this._values.size
     } : Array.from(this._values.values());
   }
-  [inspect.custom]() {
+  [_inspect_custom]() {
     return inspectObject(this);
   }
   add(value) {
@@ -458,6 +538,18 @@ var ComplexSet = class {
   isDisjointFrom(other) {
     throw new Error("Method not implemented.");
   }
+  // prettier-ignore
+  constructor(_projection, values) {
+    _define_property3(this, "_projection", void 0);
+    _define_property3(this, "_values", void 0);
+    this._projection = _projection;
+    this._values = /* @__PURE__ */ new Map();
+    if (values) {
+      for (const value of values) {
+        this.add(value);
+      }
+    }
+  }
 };
 var makeSet = (projection) => {
   return class BoundComplexSet extends ComplexSet {
@@ -466,18 +558,8 @@ var makeSet = (projection) => {
     }
   };
 };
+var _inspect_custom1 = inspect.custom;
 var ComplexMap = class _ComplexMap {
-  // prettier-ignore
-  constructor(_keyProjection, entries2) {
-    this._keyProjection = _keyProjection;
-    this._keys = /* @__PURE__ */ new Map();
-    this._values = /* @__PURE__ */ new Map();
-    if (entries2) {
-      for (const [key, value] of entries2) {
-        this.set(key, value);
-      }
-    }
-  }
   toString() {
     return inspectObject(this);
   }
@@ -486,7 +568,7 @@ var ComplexMap = class _ComplexMap {
       size: this._values.size
     } : Array.from(this._values.values());
   }
-  [inspect.custom]() {
+  [_inspect_custom1]() {
     return inspectObject(this);
   }
   clear() {
@@ -548,11 +630,28 @@ var ComplexMap = class _ComplexMap {
   get [Symbol.toStringTag]() {
     return "ComplexMap";
   }
+  // prettier-ignore
+  constructor(_keyProjection, entries2) {
+    _define_property3(this, "_keyProjection", void 0);
+    _define_property3(this, "_keys", void 0);
+    _define_property3(this, "_values", void 0);
+    this._keyProjection = _keyProjection;
+    this._keys = /* @__PURE__ */ new Map();
+    this._values = /* @__PURE__ */ new Map();
+    if (entries2) {
+      for (const [key, value] of entries2) {
+        this.set(key, value);
+      }
+    }
+  }
 };
-var makeMap = (keyProjection) => class BoundComplexMap extends ComplexMap {
-  constructor(entries2) {
-    super(keyProjection, entries2);
+var makeMap = (keyProjection) => {
+  class BoundComplexMap extends ComplexMap {
+    constructor(entries2) {
+      super(keyProjection, entries2);
+    }
   }
+  return BoundComplexMap;
 };
 
 // src/deep.ts
@@ -593,49 +692,71 @@ var getDeep = (obj, path) => {
 var deferFunction = (fnProvider) => (...args) => fnProvider()(...args);
 
 // src/explicit-resource-management-polyfill.ts
-Symbol.dispose ??= Symbol("Symbol.dispose");
-Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");
+var _Symbol;
+var _Symbol1;
+(_Symbol = Symbol).dispose ?? (_Symbol.dispose = Symbol("Symbol.dispose"));
+(_Symbol1 = Symbol).asyncDispose ?? (_Symbol1.asyncDispose = Symbol("Symbol.asyncDispose"));
 
 // src/defer.ts
+function _define_property4(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
 var defer = (fn) => new DeferGuard(fn);
 var DeferGuard = class {
-  /**
-  * @internal
-  */
-  constructor(_fn) {
-    this._fn = _fn;
-  }
   [Symbol.dispose]() {
     const result = this._fn();
     if (result instanceof Promise) {
       throw new Error("Async functions in defer are not supported. Use deferAsync instead.");
     }
   }
-};
-var deferAsync = (fn) => new DeferAsyncGuard(fn);
-var DeferAsyncGuard = class {
   /**
   * @internal
   */
   constructor(_fn) {
+    _define_property4(this, "_fn", void 0);
     this._fn = _fn;
   }
+};
+var deferAsync = (fn) => new DeferAsyncGuard(fn);
+var DeferAsyncGuard = class {
   async [Symbol.asyncDispose]() {
     await this._fn();
   }
+  /**
+  * @internal
+  */
+  constructor(_fn) {
+    _define_property4(this, "_fn", void 0);
+    this._fn = _fn;
+  }
 };
 
 // src/entry.ts
+function _define_property5(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
 var entry = (map, key) => new MapEntry(map, key);
 var MapEntry = class {
-  /**
-  * @internal
-  */
-  // prettier-ignore
-  constructor(_map, _key) {
-    this._map = _map;
-    this._key = _key;
-  }
   get key() {
     return this._key;
   }
@@ -651,6 +772,16 @@ var MapEntry = class {
   deep(key) {
     return entry(this.value, key);
   }
+  /**
+  * @internal
+  */
+  // prettier-ignore
+  constructor(_map, _key) {
+    _define_property5(this, "_map", void 0);
+    _define_property5(this, "_key", void 0);
+    this._map = _map;
+    this._key = _key;
+  }
 };
 
 // src/first-two-chars.ts
@@ -685,6 +816,19 @@ var forEachAsync = (items, fn) => Promise.all(items.map(fn));
 
 // src/human-hash.ts
 import { PublicKey } from "@dxos/keys";
+function _define_property6(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
 var DEFAULT_WORDLIST = [
   "ack",
   "alabama",
@@ -944,26 +1088,6 @@ var DEFAULT_WORDLIST = [
   "zulu"
 ];
 var HumanHasher = class {
-  /**
-  * Transforms hex digests to human-readable strings.
-  *
-  * The format of these strings will look something like:
-  * `victor-bacon-zulu-lima`. The output is obtained by compressing the input
-  * digest to a fixed number of bytes, then mapping those bytes to one of 256
-  * words. A default wordlist is provided, but you can override this if you
-  * prefer.
-  * As long as you use the same wordlist, the output will be consistent (i.e.
-  * the same digest will always render the same representation).
-  *
-  * @param wordlist A list of exactly 256 words to choose from
-  */
-  constructor(wordlist = DEFAULT_WORDLIST) {
-    this.wordlist = wordlist;
-    if (wordlist.length !== 256) {
-      throw new Error("Wordlist must have exactly 256 items");
-    }
-    this.wordlist = wordlist;
-  }
   /**
   * Humanize a given hexadecimal digest.
   *
@@ -1003,6 +1127,27 @@ var HumanHasher = class {
     const checksums = segments.map((x) => x.reduce((acc, curr) => acc ^ curr));
     return checksums;
   }
+  /**
+  * Transforms hex digests to human-readable strings.
+  *
+  * The format of these strings will look something like:
+  * `victor-bacon-zulu-lima`. The output is obtained by compressing the input
+  * digest to a fixed number of bytes, then mapping those bytes to one of 256
+  * words. A default wordlist is provided, but you can override this if you
+  * prefer.
+  * As long as you use the same wordlist, the output will be consistent (i.e.
+  * the same digest will always render the same representation).
+  *
+  * @param wordlist A list of exactly 256 words to choose from
+  */
+  constructor(wordlist = DEFAULT_WORDLIST) {
+    _define_property6(this, "wordlist", void 0);
+    this.wordlist = wordlist;
+    if (wordlist.length !== 256) {
+      throw new Error("Wordlist must have exactly 256 items");
+    }
+    this.wordlist = wordlist;
+  }
 };
 var hasher = new HumanHasher();
 var humanize = (value) => {
@@ -1025,8 +1170,10 @@ var defaultMap = (map, key, def) => {
 };
 
 // src/instance-id.ts
+var _globalThis;
+var _symbol;
 var symbol = Symbol.for("dxos.instance-contexts");
-var instanceContexts = globalThis[symbol] ??= /* @__PURE__ */ new WeakMap();
+var instanceContexts = (_globalThis = globalThis)[_symbol = symbol] ?? (_globalThis[_symbol] = /* @__PURE__ */ new WeakMap());
 var getPrototypeSpecificInstanceId = (instance) => {
   const prototype = Object.getPrototypeOf(instance);
   const instanceCtx = defaultMap(instanceContexts, prototype, () => ({
@@ -1198,6 +1345,19 @@ var jsonKeyReplacer = (options = {}) => (key, value) => {
 };
 
 // src/map-values.ts
+function _define_property7(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
 var mapValues = (obj, fn) => {
   const result = {};
   Object.keys(obj).forEach((key) => {
@@ -1209,7 +1369,19 @@ var deepMapValues = (value, fn) => {
   return new DeepMapper(fn).map(value);
 };
 var DeepMapper = class {
+  map(value) {
+    return this._map(value, void 0);
+  }
+  _map(value, key) {
+    if (this._cyclic.has(value)) {
+      return this._cyclic.get(value);
+    }
+    return this._fn(value, this._recurse, key);
+  }
   constructor(_fn) {
+    _define_property7(this, "_fn", void 0);
+    _define_property7(this, "_cyclic", void 0);
+    _define_property7(this, "_recurse", void 0);
     this._fn = _fn;
     this._cyclic = /* @__PURE__ */ new Map();
     this._recurse = (value) => {
@@ -1235,6 +1407,11 @@ var DeepMapper = class {
       }
     };
   }
+};
+var deepMapValuesAsync = (value, fn) => {
+  return new DeepMapperAsync(fn).map(value);
+};
+var DeepMapperAsync = class {
   map(value) {
     return this._map(value, void 0);
   }
@@ -1244,12 +1421,10 @@ var DeepMapper = class {
     }
     return this._fn(value, this._recurse, key);
   }
-};
-var deepMapValuesAsync = (value, fn) => {
-  return new DeepMapperAsync(fn).map(value);
-};
-var DeepMapperAsync = class {
   constructor(_fn) {
+    _define_property7(this, "_fn", void 0);
+    _define_property7(this, "_cyclic", void 0);
+    _define_property7(this, "_recurse", void 0);
     this._fn = _fn;
     this._cyclic = /* @__PURE__ */ new Map();
     this._recurse = async (value) => {
@@ -1275,15 +1450,6 @@ var DeepMapperAsync = class {
       }
     };
   }
-  map(value) {
-    return this._map(value, void 0);
-  }
-  _map(value, key) {
-    if (this._cyclic.has(value)) {
-      return this._cyclic.get(value);
-    }
-    return this._fn(value, this._recurse, key);
-  }
 };
 var visitValues = (object, visitor) => {
   if (Array.isArray(object)) {
@@ -1605,7 +1771,7 @@ var safeParseInt = (value, defaultValue) => {
   try {
     const n = parseInt(value ?? "");
     return isNaN(n) ? defaultValue : n;
-  } catch (err) {
+  } catch {
     return defaultValue;
   }
 };
@@ -1620,7 +1786,7 @@ var safeParseJson = (data, defaultValue) => {
   if (data && data.length > 0) {
     try {
       return JSON.parse(data);
-    } catch (err) {
+    } catch {
     }
   }
   return defaultValue;
@@ -1628,24 +1794,21 @@ var safeParseJson = (data, defaultValue) => {
 
 // src/sliding-window-summary.ts
 import { invariant as invariant5 } from "@dxos/invariant";
+function _define_property8(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
 var __dxlog_file5 = "/__w/dxos/dxos/packages/common/util/src/sliding-window-summary.ts";
 var SlidingWindowSummary = class {
-  constructor(options) {
-    this._sum = 0;
-    this._buffer = new CircularBuffer(options.dataPoints);
-    if (options.precision != null) {
-      invariant5(options.precision >= 0, void 0, {
-        F: __dxlog_file5,
-        L: 26,
-        S: this,
-        A: [
-          "options.precision >= 0",
-          ""
-        ]
-      });
-      this._precision = Math.pow(10, options.precision);
-    }
-  }
   record(value) {
     const evicted = this._buffer.push(value);
     this._sum += value - (evicted ?? 0);
@@ -1680,6 +1843,24 @@ var SlidingWindowSummary = class {
     }
     return Math.round(value * this._precision) / this._precision;
   }
+  constructor(options) {
+    _define_property8(this, "_buffer", void 0);
+    _define_property8(this, "_sum", 0);
+    _define_property8(this, "_precision", void 0);
+    this._buffer = new CircularBuffer(options.dataPoints);
+    if (options.precision != null) {
+      invariant5(options.precision >= 0, void 0, {
+        F: __dxlog_file5,
+        L: 26,
+        S: this,
+        A: [
+          "options.precision >= 0",
+          ""
+        ]
+      });
+      this._precision = Math.pow(10, options.precision);
+    }
+  }
 };
 
 // src/sort.ts
@@ -1711,12 +1892,23 @@ var capitalize = (str) => {
   }
   return str.charAt(0).toUpperCase() + str.slice(1);
 };
-var trim = (strings, ...values) => {
-  const full = String.raw(strings, ...values);
-  const lines = full.replace(/^\n/, "").split("\n");
-  const indent = Math.min(...lines.filter((l) => l.trim()).map((l) => l.match(/^ */)[0].length));
-  return lines.map((l) => l.slice(indent)).join("\n");
-};
+function trim(strings, ...values) {
+  const raw = strings.reduce((out, str, i) => {
+    out += str;
+    if (i < values.length) {
+      const match = str.match(/(^|\n)([ \t]*)$/);
+      const baseIndent = match ? match[2] : "";
+      const val = String(values[i]).replace(/\r?\n/g, "\n" + baseIndent);
+      out += val;
+    }
+    return out;
+  }, "");
+  const lines = raw.split("\n");
+  while (lines.length && !lines[0].trim()) lines.shift();
+  while (lines.length && !lines[lines.length - 1].trim()) lines.pop();
+  const minIndent = Math.min(...lines.filter((l) => l.trim()).map((l) => l.match(/^[ \t]*/)?.[0].length ?? 0));
+  return lines.map((l) => l.slice(minIndent)).join("\n");
+}
 
 // src/sum.ts
 var sum = (values) => values.reduce((a, b) => a + b, 0);
@@ -1914,11 +2106,20 @@ var toFallback = (hash) => {
 };
 
 // src/tracer.ts
-var Tracer = class {
-  constructor() {
-    this._events = /* @__PURE__ */ new Map();
-    this._recording = false;
+function _define_property9(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
   }
+  return obj;
+}
+var Tracer = class {
   // TODO(burdon): Start/stop methods for recording data? By id?
   //  Alternatively, enable subscriptions to track/compute series.
   // TODO(burdon): Hierarchical traces?
@@ -1975,6 +2176,10 @@ var Tracer = class {
       defaultMap(this._events, event.id, []).push(event);
     }
   }
+  constructor() {
+    _define_property9(this, "_events", /* @__PURE__ */ new Map());
+    _define_property9(this, "_recording", false);
+  }
 };
 var tracer = new Tracer();
 
@@ -2050,6 +2255,70 @@ var arrayMove = (array, from, to) => {
   return array;
 };
 
+// src/unit.ts
+var Formatter = (unit) => {
+  return (n, precision = 2) => {
+    const value = n / unit.quotient;
+    return `${value.toFixed(precision)}${unit.symbol}`;
+  };
+};
+var Unit = {
+  // ms.
+  Hour: Formatter({
+    symbol: "h",
+    quotient: 60 * 60 * 1e3
+  }),
+  Minute: Formatter({
+    symbol: "m",
+    quotient: 60 * 1e3
+  }),
+  Second: Formatter({
+    symbol: "s",
+    quotient: 1e3
+  }),
+  Millisecond: Formatter({
+    symbol: "ms",
+    quotient: 1
+  }),
+  Duration: (n) => {
+    const hours = Math.floor(n / (60 * 60 * 1e3));
+    const minutes = Math.floor(n % (60 * 60 * 1e3) / (60 * 1e3));
+    if (hours) {
+      return minutes ? `${hours}h ${minutes}m` : `${hours}h`;
+    }
+    const seconds = Math.floor(n % (60 * 1e3) / 1e3);
+    if (minutes) {
+      return seconds ? `${minutes}m ${seconds}s` : `${minutes}m`;
+    }
+    if (seconds) {
+      return `${(n / 1e3).toFixed(1)}s`;
+    }
+    return `${n}ms`;
+  },
+  // bytes (note KB via KiB).
+  Gigabyte: Formatter({
+    symbol: "GB",
+    quotient: 1e3 * 1e3 * 1e3
+  }),
+  Megabyte: Formatter({
+    symbol: "MB",
+    quotient: 1e3 * 1e3
+  }),
+  Kilobyte: Formatter({
+    symbol: "KB",
+    quotient: 1e3
+  }),
+  // general.
+  Thousand: Formatter({
+    symbol: "k",
+    quotient: 1e3
+  }),
+  Percent: Formatter({
+    symbol: "%",
+    quotient: 1 / 100
+  })
+};
+
 // src/url.ts
 var createUrl = (url, search) => {
   const base = typeof url === "string" ? new URL(url) : url;
@@ -2060,18 +2329,20 @@ var createUrl = (url, search) => {
 };
 
 // src/weak.ts
-var WeakDictionary = class {
-  constructor(entries2) {
-    this._internal = /* @__PURE__ */ new Map();
-    this._finalization = new FinalizationRegistry((cleanUpCallback) => {
-      cleanUpCallback();
+function _define_property10(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
     });
-    this._internal = new Map(entries2?.map(([key, value]) => [
-      key,
-      new WeakRef(value)
-    ]));
-    entries2?.forEach(([key, value]) => this._register(key, value));
+  } else {
+    obj[key] = value;
   }
+  return obj;
+}
+var WeakDictionary = class {
   *entries() {
     for (const [key, value] of this._internal) {
       yield [
@@ -2152,6 +2423,17 @@ var WeakDictionary = class {
   _unregister(value) {
     this._finalization.unregister(value);
   }
+  constructor(entries2) {
+    _define_property10(this, "_internal", /* @__PURE__ */ new Map());
+    _define_property10(this, "_finalization", new FinalizationRegistry((cleanUpCallback) => {
+      cleanUpCallback();
+    }));
+    this._internal = new Map(entries2?.map(([key, value]) => [
+      key,
+      new WeakRef(value)
+    ]));
+    entries2?.forEach(([key, value]) => this._register(key, value));
+  }
 };
 export {
   BitField,
@@ -2164,6 +2446,7 @@ export {
   MapEntry,
   SlidingWindowSummary,
   Tracer,
+  Unit,
   WeakDictionary,
   accessBy,
   arrayMove,