@agrotools1/at-components 0.2.4 → 0.2.5

package/dist/MediaLayerView2D-64897044.js

@@ -0,0 +1,332 @@
+import { aS as X, o as q, P as $, Q as I, p as Z, f$ as ee, s as B, W as te, fj as re, g0 as se, fd as ie, g1 as ne, f6 as oe, fb as ae, f7 as le, f8 as he, g2 as me, f9 as pe, aH as ce, g3 as de, V as ue, H as U, m as fe, f as ye, g4 as _e, i as ge, b3 as ve, a3 as we, e as A, y as L, c as Re, aG as xe, g5 as $e } from "./index-6ebf29c1.js";
+import "./UniqueValueRenderer-3d92c0b9.js";
+import "./jsonUtils-1f447d0c.js";
+import { j as Me, m as W } from "./perspectiveUtils-1b383b17.js";
+import "./colorUtils-6d5e716b.js";
+import "./GeometryUtils-058e30f4.js";
+import "./UpdateTracking2D-23c8ff3f.js";
+import { d as P } from "./enums-fa8f05ab.js";
+import "./definitions-a00a3a6c.js";
+import "./defaults-b7c93d2a.js";
+import "./OverrideHelper-f8aace2c.js";
+import "./floatRGBA-005cc596.js";
+import { i as Ee, E as be } from "./Container-f931e682.js";
+import { n as Ve, h as Te } from "./WGLContainer-f05c906a.js";
+import "./vec4f32-b2628ced.js";
+import { e as Se, m as z } from "./Texture-b1727861.js";
+import { D as Ce, F as Q } from "./enums-2c166c09.js";
+import "./Program-ed5a5aa3.js";
+import "./LabelMetric-ee740bd1.js";
+import "./StyleDefinition-f4862d5a.js";
+import "./enums-25d066fc.js";
+import "./MagnifierPrograms-1584f9b5.js";
+import "./pbf-0b9b579c.js";
+import "./FeatureCommandQueue-4e426066.js";
+import "./OrderIndependentTransparency-3eadfe42.js";
+import "./testSVGPremultipliedAlpha-b9ff88ef.js";
+import "./GraphicsView2D-963eb026.js";
+import "./earcut-ffaa9a50.js";
+import { r as qe } from "./vec3f32-304a6a9c.js";
+import { e as Ae } from "./mat3f64-03233387.js";
+import { f as Pe } from "./utils-f46de72c.js";
+import { h as k } from "./BufferObject-22d914df.js";
+import { o as De } from "./VertexArrayObject-08a9d938.js";
+import { m as Ge, u as He } from "./LayerView-e41297e4.js";
+import "vue";
+import "./ColorStop-5009138a.js";
+import "./diffUtils-54c1c039.js";
+import "./colorRamps-0fae1fde.js";
+import "./sizeVariableUtils-a1b694d8.js";
+import "./visualVariableUtils-bc9bfef1.js";
+import "./lengthUtils-6a89d855.js";
+import "./jsonUtils-db906457.js";
+import "./styleUtils-aa4777b6.js";
+import "./LRUCache-fc532e9b.js";
+import "./MemCache-0861cc28.js";
+import "./Version-d45bee25.js";
+import "./FieldsIndex-91fb234a.js";
+import "./UnknownTimeZone-ed4def19.js";
+import "./utils-e73651cf.js";
+import "./heatmapUtils-b512588d.js";
+import "./vec42-27060a00.js";
+import "./vec4f64-043e974c.js";
+import "./normalizeUtilsSync-555b1847.js";
+import "./TurboLine-708823a3.js";
+import "./OptimizedGeometry-3b808152.js";
+import "./Rect-894f011c.js";
+import "./BindType-5e76c8e1.js";
+import "./Util-2ba07f64.js";
+import "./highlightReasons-b0f772b2.js";
+import "./constants-5bd557fe.js";
+import "./defaultsJSON-ba17aa15.js";
+import "./quantizationUtils-9e478e23.js";
+import "./parser-7a76caf9.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./ProgramTemplate-976cfde1.js";
+import "./config-61215215.js";
+import "./featureConversionUtils-a5f0b9b2.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./CircularArray-b2bc1dfd.js";
+import "./AttributeStore-3851ad0b.js";
+import "./labelUtils-85708580.js";
+import "./TimeOnly-5a143001.js";
+import "./timeSupport-8d2432f7.js";
+import "./json-5febf88a.js";
+import "./basicInterfaces-fa4f5fa7.js";
+import "./scaleUtils-ba5596ad.js";
+const y = Ae(), Oe = { none: P.None, loop: P.Loop, oscillate: P.Oscillate };
+function je(r) {
+  return r ? { ...r, playAnimation: r.playing, repeatType: r.repeatType ? Oe[r.repeatType] : void 0 } : {};
+}
+class Ie extends Ee {
+  constructor(e) {
+    super(), this.elementView = e, this.isWrapAround = !1, this.perspectiveTransform = X(), this._playHandle = null, this._vertices = new Float32Array(20), this._handles = [], this._handles.push(q(() => this.elementView.element.opacity, (t) => this.opacity = t, $), q(() => [this.elementView.coords], () => {
+      this.requestRender();
+    }, $), q(() => ["animationOptions" in this.elementView.element && this.elementView.element.animationOptions], () => {
+      var t;
+      (t = this._playHandle) == null || t.remove(), this.texture = I(this.texture), this.requestRender();
+    }, $), Z(() => this.elementView.element.loaded, () => {
+      const t = this.elementView.element;
+      this.ready(), t.type === "video" && t.content != null && this._handles.push(ee(t.content, "play", () => this.requestRender()));
+    }, $)), e.element.load().catch((t) => {
+      B.getLogger("esri.views.2d.layers.MediaLayerView2D").error(new te("element-load-error", "Element cannot be displayed", { element: e, error: t }));
+    });
+  }
+  getMesh(e) {
+    throw new Error("Method not implemented.");
+  }
+  destroy() {
+    var e;
+    (e = this._playHandle) == null || e.remove(), this._handles.forEach((t) => t.remove()), this.texture = I(this.texture);
+  }
+  get dvsMat3() {
+    return this.parent.dvsMat3;
+  }
+  beforeRender(e) {
+    const { context: t } = e, s = this.elementView.element.content;
+    if (s != null) {
+      const i = s instanceof HTMLImageElement, n = s instanceof HTMLVideoElement, h = i ? s.naturalWidth : n ? s.videoWidth : s.width, o = i ? s.naturalHeight : n ? s.videoHeight : s.height;
+      if (this._updatePerspectiveTransform(h, o), this.texture)
+        n && !s.paused && (this.texture.setData(s), this.requestRender(), this.texture.generateMipmap());
+      else {
+        const m = new Se();
+        if (m.wrapMode = Ce.CLAMP_TO_EDGE, m.preMultiplyAlpha = !0, m.width = h, m.height = o, "getFrame" in s) {
+          const l = (a) => {
+            this.texture ? this.texture.setData(a) : this.texture = new z(t, m, a), this.requestRender();
+          };
+          "animationOptions" in this.elementView.element && (this._playHandle = Pe(s, je(this.elementView.element.animationOptions), null, l));
+        } else
+          this.texture = new z(t, m, s);
+        this.texture.generateMipmap(), n && !s.paused && this.requestRender();
+      }
+    }
+    super.beforeRender(e);
+  }
+  _createTransforms() {
+    return null;
+  }
+  updateDrawCoords(e, t) {
+    const s = this.elementView.coords;
+    if (s == null)
+      return;
+    const [i, n, h, o] = s.rings[0], m = this._vertices, { x: l, y: a } = e, d = t !== 0;
+    d ? m.set([n[0] - l, n[1] - a, i[0] - l, i[1] - a, h[0] - l, h[1] - a, o[0] - l, o[1] - a, o[0] - l, o[1] - a, n[0] + t - l, n[1] - a, n[0] + t - l, n[1] - a, i[0] + t - l, i[1] - a, h[0] + t - l, h[1] - a, o[0] + t - l, o[1] - a]) : m.set([n[0] - l, n[1] - a, i[0] - l, i[1] - a, h[0] - l, h[1] - a, o[0] - l, o[1] - a]), this.isWrapAround = d;
+  }
+  getVAO(e, t, s) {
+    if (this.elementView.coords == null)
+      return null;
+    const i = this._vertices;
+    if (this._vao)
+      this._geometryVbo.setData(i);
+    else {
+      this._geometryVbo = k.createVertex(e, Q.DYNAMIC_DRAW, i);
+      const n = k.createVertex(e, Q.STATIC_DRAW, new Uint16Array([0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1]));
+      this._vao = new De(e, s, t, { geometry: this._geometryVbo, tex: n });
+    }
+    return this._vao;
+  }
+  _updatePerspectiveTransform(e, t) {
+    const s = this._vertices;
+    Me(y, [0, 0, e, 0, 0, t, e, t], [s[0], s[1], s[4], s[5], s[2], s[3], s[6], s[7]]), re(this.perspectiveTransform, y[6] / y[8] * e, y[7] / y[8] * t);
+  }
+}
+class Ue extends Ve {
+  constructor() {
+    super(...arguments), this._localOrigin = se(0, 0), this._viewStateId = -1, this._dvsMat3 = ie();
+  }
+  get dvsMat3() {
+    return this._dvsMat3;
+  }
+  beforeRender(e) {
+    this._updateMatrices(e), this._updateOverlays(e, this.children);
+    for (const t of this.children)
+      t.beforeRender(e);
+  }
+  prepareRenderPasses(e) {
+    const t = e.registerRenderPass({ name: "overlay", brushes: [Te.overlay], target: () => this.children, drawPhase: be.MAP });
+    return [...super.prepareRenderPasses(e), t];
+  }
+  _updateMatrices(e) {
+    const { state: t } = e, { id: s, size: i, pixelRatio: n, resolution: h, rotation: o, viewpoint: m, displayMat3: l } = t;
+    if (this._viewStateId === s)
+      return;
+    const a = Math.PI / 180 * o, d = n * i[0], f = n * i[1], { x: M, y: v } = m.targetGeometry, E = ne(M, t.spatialReference);
+    this._localOrigin.x = E, this._localOrigin.y = v;
+    const b = h * d, w = h * f, p = oe(this._dvsMat3);
+    ae(p, p, l), le(p, p, he(d / 2, f / 2)), me(p, p, qe(d / b, -f / w, 1)), pe(p, p, -a), this._viewStateId = s;
+  }
+  _updateOverlays(e, t) {
+    const { state: s } = e, { rotation: i, spatialReference: n, worldScreenWidth: h, size: o, viewpoint: m } = s, l = this._localOrigin;
+    let a = 0;
+    const d = ce(n);
+    if (d && n.isWrappable) {
+      const f = o[0], M = o[1], v = 180 / Math.PI * i, E = Math.abs(Math.cos(v)), b = Math.abs(Math.sin(v)), w = Math.round(f * E + M * b), [p, V] = d.valid, u = de(n), { x: D, y: N } = m.targetGeometry, Y = [D, N], T = [0, 0];
+      s.toScreen(T, Y);
+      const R = [0, 0];
+      let S;
+      S = w > h ? 0.5 * h : 0.5 * w;
+      const G = Math.floor((D + 0.5 * u) / u), J = p + G * u, K = V + G * u, C = [T[0] + S, 0];
+      s.toMap(R, C), R[0] > K && (a = u), C[0] = T[0] - S, s.toMap(R, C), R[0] < J && (a = -u);
+      for (const x of t) {
+        const H = x.elementView.bounds;
+        if (H == null)
+          continue;
+        const [O, , j] = H;
+        O < p && j > p ? x.updateDrawCoords(l, u) : j > V && O < V ? x.updateDrawCoords(l, -u) : x.updateDrawCoords(l, a);
+      }
+    } else
+      for (const f of t)
+        f.updateDrawCoords(l, a);
+  }
+}
+let g = class extends Ge(He) {
+  constructor() {
+    super(...arguments), this._overlayContainer = null, this._fetchQueue = null, this._tileStrategy = null, this._elementReferences = /* @__PURE__ */ new Map(), this._debugGraphicsView = null, this.layer = null, this.elements = new ue();
+  }
+  attach() {
+    this.addAttachHandles([U(() => this.layer.effectiveSource, "refresh", () => {
+      this._tileStrategy.refresh((r) => this._updateTile(r)), this.requestUpdate();
+    }), U(() => this.layer.effectiveSource, "change", ({ element: r }) => this._elementUpdateHandler(r))]), this._overlayContainer = new Ue(), this.container.addChild(this._overlayContainer), this._fetchQueue = new fe({ tileInfoView: this.view.featuresTilingScheme, concurrency: 10, process: (r, e) => this._queryElements(r, e) }), this._tileStrategy = new ye({ cachePolicy: "purge", resampling: !0, acquireTile: (r) => this._acquireTile(r), releaseTile: (r) => this._releaseTile(r), tileInfoView: this.view.featuresTilingScheme }), this.requestUpdate();
+  }
+  detach() {
+    var r;
+    this.elements.removeAll(), this._tileStrategy.destroy(), this._fetchQueue.destroy(), this._overlayContainer.removeAllChildren(), this.container.removeAllChildren(), this._elementReferences.clear(), (r = this._debugGraphicsView) == null || r.destroy();
+  }
+  supportsSpatialReference(r) {
+    return !0;
+  }
+  moveStart() {
+    this.requestUpdate();
+  }
+  viewChange() {
+    this.requestUpdate();
+  }
+  moveEnd() {
+    this.requestUpdate();
+  }
+  update(r) {
+    var e;
+    this._tileStrategy.update(r), (e = this._debugGraphicsView) == null || e.update(r);
+  }
+  async hitTest(r, e) {
+    const t = [], s = r.normalize(), i = [s.x, s.y];
+    for (const { projectedElement: { normalizedCoords: n, element: h } } of this._elementReferences.values())
+      n != null && _e(n.rings, i) && t.push({ type: "media", element: h, layer: this.layer, mapPoint: r, sourcePoint: h.toSource(r) });
+    return t.reverse();
+  }
+  canResume() {
+    return this.layer.source != null && super.canResume();
+  }
+  async doRefresh() {
+    this._fetchQueue.reset(), this._tileStrategy.refresh((r) => this._updateTile(r));
+  }
+  _acquireTile(r) {
+    const e = new Le(r.clone());
+    return this._updateTile(e), e;
+  }
+  _updateTile(r) {
+    this._updatingHandles.addPromise(this._fetchQueue.push(r.key).then((e) => {
+      const [t, s] = r.setElements(e);
+      this._referenceElements(r, t), this._dereferenceElements(r, s), this.requestUpdate();
+    }, (e) => {
+      ge(e) || B.getLogger(this).error(e);
+    }));
+  }
+  _releaseTile(r) {
+    this._fetchQueue.abort(r.key.id), r.elements && this._dereferenceElements(r, r.elements), this.requestUpdate();
+  }
+  async _queryElements(r, e) {
+    const t = this.layer.effectiveSource;
+    if (t == null)
+      return [];
+    this.view.featuresTilingScheme.getTileBounds(c, r, !0);
+    const s = new ve({ xmin: c[0], ymin: c[1], xmax: c[2], ymax: c[3], spatialReference: this.view.spatialReference });
+    return t.queryElements(s, e);
+  }
+  _referenceElements(r, e) {
+    if (this.layer.source != null)
+      for (const t of e)
+        this._referenceElement(r, t);
+  }
+  _referenceElement(r, e) {
+    we(this._elementReferences, e.uid, () => {
+      const t = new W({ element: e, spatialReference: this.view.spatialReference }), s = new Ie(t);
+      return this._overlayContainer.addChild(s), this.elements.add(e), { tiles: /* @__PURE__ */ new Set(), projectedElement: t, overlay: s, debugGraphic: null };
+    }).tiles.add(r);
+  }
+  _dereferenceElements(r, e) {
+    for (const t of e)
+      this._dereferenceElement(r, t);
+  }
+  _dereferenceElement(r, e) {
+    var s;
+    const t = this._elementReferences.get(e.uid);
+    t.tiles.delete(r), t.tiles.size || (this._overlayContainer.removeChild(t.overlay), t.overlay.destroy(), t.projectedElement.destroy(), this._elementReferences.delete(e.uid), this.elements.remove(e), (s = this._debugGraphicsView) == null || s.graphics.remove(t.debugGraphic));
+  }
+  _elementUpdateHandler(r) {
+    var s;
+    let e = this._elementReferences.get(r.uid);
+    if (e) {
+      const i = e.projectedElement.normalizedCoords;
+      if (i == null)
+        return this._overlayContainer.removeChild(e.overlay), e.overlay.destroy(), e.projectedElement.destroy(), this._elementReferences.delete(r.uid), this.elements.remove(r), void ((s = this._debugGraphicsView) == null ? void 0 : s.graphics.remove(e.debugGraphic));
+      const n = [], h = [];
+      for (const o of this._tileStrategy.tiles) {
+        const m = F(this.view.featuresTilingScheme, o, i);
+        e.tiles.has(o) ? m || h.push(o) : m && n.push(o);
+      }
+      for (const o of n)
+        this._referenceElement(o, r);
+      for (const o of h)
+        this._dereferenceElement(o, r);
+      return e = this._elementReferences.get(r.uid), void ((e == null ? void 0 : e.debugGraphic) && (e.debugGraphic.geometry = e.projectedElement.normalizedCoords, this._debugGraphicsView.graphicUpdateHandler({ graphic: e.debugGraphic, property: "geometry" })));
+    }
+    const t = new W({ element: r, spatialReference: this.view.spatialReference }).normalizedCoords;
+    if (t != null)
+      for (const i of this._tileStrategy.tiles)
+        F(this.view.featuresTilingScheme, i, t) && this._referenceElement(i, r);
+  }
+};
+A([L()], g.prototype, "layer", void 0), A([L({ readOnly: !0 })], g.prototype, "elements", void 0), g = A([Re("esri.views.2d.layers.MediaLayerView2D")], g);
+const c = xe(), _ = { xmin: 0, ymin: 0, xmax: 0, ymax: 0 };
+function F(r, e, t) {
+  return r.getTileBounds(c, e.key, !0), _.xmin = c[0], _.ymin = c[1], _.xmax = c[2], _.ymax = c[3], $e(_, t);
+}
+class Le {
+  constructor(e) {
+    this.key = e, this.elements = null, this.isReady = !1, this.visible = !0;
+  }
+  setElements(e) {
+    const t = [], s = new Set(this.elements);
+    this.elements = e;
+    for (const i of e)
+      s.has(i) ? s.delete(i) : t.push(i);
+    return this.isReady = !0, [t, Array.from(s)];
+  }
+  destroy() {
+  }
+}
+const mr = g;
+export {
+  mr as default
+};

package/dist/MemCache-0861cc28.js

@@ -0,0 +1,227 @@
+import { bH as z } from "./index-6ebf29c1.js";
+const c = -3, f = c - 1;
+var n;
+(function(_) {
+  _[_.ALL = 0] = "ALL", _[_.SOME = 1] = "SOME";
+})(n || (n = {}));
+class b {
+  constructor(i, t, e) {
+    this.name = i, this._storage = t, this.id = g++ + ":", this.size = 0, this.maxSize = -1, this._removeFunc = !1, this._hit = 0, this._miss = 0, this._storage.register(this), e && (this._storage.registerRemoveFunc(this.id, e), this._removeFunc = !0);
+  }
+  destroy() {
+    this._storage.clear(this), this._removeFunc && this._storage.deregisterRemoveFunc(this.id), this._storage.deregister(this), this._storage = null;
+  }
+  get hitRate() {
+    return this._hit / (this._hit + this._miss);
+  }
+  get storageSize() {
+    return this._storage.size;
+  }
+  getSize(i) {
+    return this._storage.getSize(this, i);
+  }
+  resetHitRate() {
+    this._hit = this._miss = 0;
+  }
+  put(i, t, e, h = 0) {
+    this._storage.put(this, i, t, e, h);
+  }
+  pop(i) {
+    const t = this._storage.pop(this, i);
+    return t === void 0 ? ++this._miss : ++this._hit, t;
+  }
+  get(i) {
+    const t = this._storage.get(this, i);
+    return t === void 0 ? ++this._miss : ++this._hit, t;
+  }
+  peek(i) {
+    return this._storage.peek(this, i);
+  }
+  updateSize(i, t, e) {
+    this._storage.updateSize(this, i, t, e);
+  }
+  clear() {
+    this._storage.clear(this);
+  }
+  clearAll() {
+    this._storage.clearAll();
+  }
+  get performanceInfo() {
+    return this._storage.performanceInfo;
+  }
+  resetStats() {
+    this._storage.resetStats();
+  }
+}
+class p {
+  get size() {
+    return this._size;
+  }
+  constructor(i = 10485760) {
+    this._maxSize = i, this._db = /* @__PURE__ */ new Map(), this._size = 0, this._hit = 0, this._miss = 0, this._removeFuncs = new z(), this._users = new z();
+  }
+  destroy() {
+    this.clearAll(), this._removeFuncs.clear(), this._users.clear(), this._db = null;
+  }
+  register(i) {
+    this._users.push(i);
+  }
+  deregister(i) {
+    this._users.removeUnordered(i);
+  }
+  registerRemoveFunc(i, t) {
+    this._removeFuncs.push([i, t]);
+  }
+  deregisterRemoveFunc(i) {
+    this._removeFuncs.filterInPlace((t) => t[0] !== i);
+  }
+  get maxSize() {
+    return this._maxSize;
+  }
+  set maxSize(i) {
+    this._maxSize = Math.max(i, -1), this._checkSize();
+  }
+  getSize(i, t) {
+    const e = this._db.get(i.id + t);
+    return (e == null ? void 0 : e.size) ?? 0;
+  }
+  put(i, t, e, h, r) {
+    t = i.id + t;
+    const s = this._db.get(t);
+    if (s && (this._size -= s.size, i.size -= s.size, this._db.delete(t), s.entry !== e && this._notifyRemove(t, s.entry, s.size, n.ALL)), h > this._maxSize)
+      return void this._notifyRemove(t, e, h, n.ALL);
+    if (e === void 0)
+      return void console.warn("Refusing to cache undefined entry ");
+    if (!h || h < 0)
+      return console.warn(`Refusing to cache entry with size ${h} for key ${t}`), void this._notifyRemove(t, e, 0, n.ALL);
+    const o = 1 + Math.max(r, f) - c;
+    this._db.set(t, new S(e, h, o)), this._size += h, i.size += h, this._checkSize();
+  }
+  updateSize(i, t, e, h) {
+    t = i.id + t;
+    const r = this._db.get(t);
+    if (r && r.entry === e) {
+      for (this._size -= r.size, i.size -= r.size; h > this._maxSize; ) {
+        const s = this._notifyRemove(t, e, h, n.SOME);
+        if (!(s != null && s > 0))
+          return void this._db.delete(t);
+        h = s;
+      }
+      r.size = h, this._size += h, i.size += h, this._checkSize();
+    }
+  }
+  pop(i, t) {
+    t = i.id + t;
+    const e = this._db.get(t);
+    if (e)
+      return this._size -= e.size, i.size -= e.size, this._db.delete(t), ++this._hit, e.entry;
+    ++this._miss;
+  }
+  get(i, t) {
+    t = i.id + t;
+    const e = this._db.get(t);
+    if (e !== void 0)
+      return this._db.delete(t), e.lives = e.lifetime, this._db.set(t, e), ++this._hit, e.entry;
+    ++this._miss;
+  }
+  peek(i, t) {
+    const e = this._db.get(i.id + t);
+    return e ? ++this._hit : ++this._miss, e == null ? void 0 : e.entry;
+  }
+  get performanceInfo() {
+    const i = { Size: Math.round(this._size / 1048576) + "/" + Math.round(this._maxSize / 1048576) + "MB", "Hit rate": Math.round(100 * this._getHitRate()) + "%", Entries: this._db.size.toString() }, t = {}, e = new Array();
+    this._db.forEach((s, o) => {
+      const a = s.lifetime;
+      e[a] = (e[a] || 0) + s.size, this._users.forAll((d) => {
+        const { id: m, name: u } = d;
+        if (o.startsWith(m)) {
+          const l = t[u] || 0;
+          t[u] = l + s.size;
+        }
+      });
+    });
+    const h = {};
+    this._users.forAll((s) => {
+      const o = s.name;
+      if ("hitRate" in s && typeof s.hitRate == "number" && !isNaN(s.hitRate) && s.hitRate > 0) {
+        const a = t[o] || 0;
+        t[o] = a, h[o] = Math.round(100 * s.hitRate) + "%";
+      } else
+        h[o] = "0%";
+    });
+    const r = Object.keys(t);
+    r.sort((s, o) => t[o] - t[s]), r.forEach((s) => i[s] = Math.round(t[s] / 2 ** 20) + "MB / " + h[s]);
+    for (let s = e.length - 1; s >= 0; --s) {
+      const o = e[s];
+      o && (i["Priority " + (s + c - 1)] = Math.round(o / this._size * 100) + "%");
+    }
+    return i;
+  }
+  resetStats() {
+    this._hit = this._miss = 0, this._users.forAll((i) => i.resetHitRate());
+  }
+  clear(i) {
+    const t = i.id;
+    this._db.forEach((e, h) => {
+      h.startsWith(t) && (this._size -= e.size, this._db.delete(h), this._notifyRemove(h, e.entry, e.size, n.ALL));
+    }), i.size = 0;
+  }
+  clearAll() {
+    this._db.forEach((i, t) => this._notifyRemove(t, i.entry, i.size, n.ALL)), this._users.forAll((i) => i.size = 0), this._size = 0, this._db.clear();
+  }
+  _getHitRate() {
+    return this._hit / (this._hit + this._miss);
+  }
+  _notifyRemove(i, t, e, h) {
+    let r;
+    return this._removeFuncs.some((s) => {
+      if (i.startsWith(s[0])) {
+        const o = s[1](t, h, e);
+        return typeof o == "number" && (r = o), !0;
+      }
+      return !1;
+    }), r;
+  }
+  _checkSize() {
+    this._users.forAll((i) => this._checkSizeLimits(i)), this._checkSizeLimits();
+  }
+  _checkSizeLimits(i) {
+    const t = i ?? this;
+    if (t.maxSize < 0 || t.size <= t.maxSize)
+      return;
+    const e = i == null ? void 0 : i.id;
+    let h = !0;
+    for (; h; ) {
+      h = !1;
+      for (const [r, s] of this._db)
+        if (s.lifetime === 0 && (!e || r.startsWith(e))) {
+          if (this._purgeItem(r, s, i), t.size <= 0.9 * t.maxSize)
+            return;
+          h || (h = this._db.has(r));
+        }
+    }
+    for (const [r, s] of this._db)
+      if ((!e || r.startsWith(e)) && (this._purgeItem(r, s, i), t.size <= 0.9 * t.maxSize))
+        return;
+  }
+  _purgeItem(i, t, e = this._users.find((h) => i.startsWith(h.id))) {
+    if (this._db.delete(i), t.lives <= 1) {
+      this._size -= t.size, e && (e.size -= t.size);
+      const h = this._notifyRemove(i, t.entry, t.size, n.SOME);
+      h != null && h > 0 && (this._size += h, e && (e.size += h), t.lives = t.lifetime, t.size = h, this._db.set(i, t));
+    } else
+      --t.lives, this._db.set(i, t);
+  }
+}
+let g = 0;
+class S {
+  constructor(i, t, e) {
+    this.entry = i, this.size = t, this.lifetime = e, this.lives = e;
+  }
+}
+export {
+  p as h,
+  n as i,
+  b as r,
+  f as s
+};