"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);

// src/utils/maps.tsx
var maps_exports = {};
__export(maps_exports, {
  DependenciesMap: () => DependenciesMap,
  IterableWeakMap: () => IterableWeakMap,
  MaybeWeakMap: () => MaybeWeakMap,
  WeakRefIfAvailable: () => WeakRefIfAvailable
});
module.exports = __toCommonJS(maps_exports);
var import_results = require("./results");
var WeakRefIfAvailable = class {
  constructor(value) {
    if (typeof WeakRef === "undefined") {
      this._ref = { deref: () => value };
    } else {
      this._ref = new WeakRef(value);
    }
  }
  deref() {
    return this._ref.deref();
  }
};
var _a, _b;
var IterableWeakMap = class {
  constructor(entries) {
    this[_a] = "IterableWeakMap";
    const mappedEntries = entries?.map((e) => [e[0], { value: e[1], keyRef: new WeakRefIfAvailable(e[0]) }]);
    this._weakMap = new WeakMap(mappedEntries ?? []);
    this._keyRefs = new Set(mappedEntries?.map((e) => e[1].keyRef) ?? []);
  }
  get(key) {
    return this._weakMap.get(key)?.value;
  }
  set(key, value) {
    const existing = this._weakMap.get(key);
    const updated = { value, keyRef: existing?.keyRef ?? new WeakRefIfAvailable(key) };
    this._weakMap.set(key, updated);
    this._keyRefs.add(updated.keyRef);
    return this;
  }
  delete(key) {
    const res = this._weakMap.get(key);
    if (res) {
      this._weakMap.delete(key);
      this._keyRefs.delete(res.keyRef);
      return true;
    }
    return false;
  }
  has(key) {
    return this._weakMap.has(key) && this._keyRefs.has(this._weakMap.get(key).keyRef);
  }
  *[(_b = Symbol.iterator, _a = Symbol.toStringTag, _b)]() {
    for (const keyRef of this._keyRefs) {
      const key = keyRef.deref();
      const existing = key ? this._weakMap.get(key) : void 0;
      if (!key) {
        this._keyRefs.delete(keyRef);
      } else if (existing) {
        yield [key, existing.value];
      }
    }
  }
};
var _a2, _b2;
var MaybeWeakMap = class {
  constructor(entries) {
    this[_a2] = "MaybeWeakMap";
    const entriesArray = [...entries ?? []];
    this._primitiveMap = new Map(entriesArray.filter((e) => !this._isAllowedInWeakMap(e[0])));
    this._weakMap = new IterableWeakMap(entriesArray.filter((e) => this._isAllowedInWeakMap(e[0])));
  }
  _isAllowedInWeakMap(key) {
    return typeof key === "object" && key !== null || typeof key === "symbol" && Symbol.keyFor(key) === void 0;
  }
  get(key) {
    if (this._isAllowedInWeakMap(key)) {
      return this._weakMap.get(key);
    } else {
      return this._primitiveMap.get(key);
    }
  }
  set(key, value) {
    if (this._isAllowedInWeakMap(key)) {
      this._weakMap.set(key, value);
    } else {
      this._primitiveMap.set(key, value);
    }
    return this;
  }
  delete(key) {
    if (this._isAllowedInWeakMap(key)) {
      return this._weakMap.delete(key);
    } else {
      return this._primitiveMap.delete(key);
    }
  }
  has(key) {
    if (this._isAllowedInWeakMap(key)) {
      return this._weakMap.has(key);
    } else {
      return this._primitiveMap.has(key);
    }
  }
  *[(_b2 = Symbol.iterator, _a2 = Symbol.toStringTag, _b2)]() {
    yield* this._primitiveMap;
    yield* this._weakMap;
  }
};
var _a3, _b3;
var DependenciesMap = class {
  constructor() {
    this._inner = { map: new MaybeWeakMap(), hasValue: false, value: void 0 };
    this[_a3] = "DependenciesMap";
  }
  _valueToResult(inner) {
    if (inner.hasValue) {
      return import_results.Result.ok(inner.value);
    } else {
      return import_results.Result.error(void 0);
    }
  }
  _unwrapFromInner(dependencies, inner) {
    if (dependencies.length === 0) {
      return this._valueToResult(inner);
    } else {
      const [key, ...rest] = dependencies;
      const newInner = inner.map.get(key);
      if (!newInner) {
        return import_results.Result.error(void 0);
      }
      return this._unwrapFromInner(rest, newInner);
    }
  }
  _setInInner(dependencies, value, inner) {
    if (dependencies.length === 0) {
      const res = this._valueToResult(inner);
      if (value.status === "ok") {
        inner.hasValue = true;
        inner.value = value.data;
      } else {
        inner.hasValue = false;
        inner.value = void 0;
      }
      return res;
    } else {
      const [key, ...rest] = dependencies;
      let newInner = inner.map.get(key);
      if (!newInner) {
        inner.map.set(key, newInner = { map: new MaybeWeakMap(), hasValue: false, value: void 0 });
      }
      return this._setInInner(rest, value, newInner);
    }
  }
  *_iterateInner(dependencies, inner) {
    if (inner.hasValue) {
      yield [dependencies, inner.value];
    }
    for (const [key, value] of inner.map) {
      yield* this._iterateInner([...dependencies, key], value);
    }
  }
  get(dependencies) {
    return import_results.Result.or(this._unwrapFromInner(dependencies, this._inner), void 0);
  }
  set(dependencies, value) {
    this._setInInner(dependencies, import_results.Result.ok(value), this._inner);
    return this;
  }
  delete(dependencies) {
    return this._setInInner(dependencies, import_results.Result.error(void 0), this._inner).status === "ok";
  }
  has(dependencies) {
    return this._unwrapFromInner(dependencies, this._inner).status === "ok";
  }
  clear() {
    this._inner = { map: new MaybeWeakMap(), hasValue: false, value: void 0 };
  }
  *[(_b3 = Symbol.iterator, _a3 = Symbol.toStringTag, _b3)]() {
    yield* this._iterateInner([], this._inner);
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  DependenciesMap,
  IterableWeakMap,
  MaybeWeakMap,
  WeakRefIfAvailable
});
//# sourceMappingURL=maps.js.map