@agrotools1/at-components 0.2.5 → 0.2.8-5

package/dist/Avatar/Avatar.d.ts

@@ -0,0 +1,66 @@
+export interface AvatarProps {
+    imgBase64?: string | null;
+    username: string;
+    size: "G" | "M" | "P";
+}
+declare const _default: import("vue").DefineComponent<{
+    imgBase64: {
+        required: false;
+        type: StringConstructor;
+        default: null;
+        validator: (value: string) => boolean;
+    };
+    withIcon: {
+        required: false;
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: boolean) => boolean;
+    };
+    username: {
+        required: true;
+        type: StringConstructor;
+        default: null;
+        validator: (value: string) => boolean;
+    };
+    size: {
+        required: false;
+        type: () => "P" | "M" | "G";
+        default: string;
+        validator: (value: string) => boolean;
+    };
+}, {
+    slotSize: import("vue").ComputedRef<string>;
+    fontSize: import("vue").ComputedRef<string>;
+    text: string;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    imgBase64: {
+        required: false;
+        type: StringConstructor;
+        default: null;
+        validator: (value: string) => boolean;
+    };
+    withIcon: {
+        required: false;
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: boolean) => boolean;
+    };
+    username: {
+        required: true;
+        type: StringConstructor;
+        default: null;
+        validator: (value: string) => boolean;
+    };
+    size: {
+        required: false;
+        type: () => "P" | "M" | "G";
+        default: string;
+        validator: (value: string) => boolean;
+    };
+}>>, {
+    size: "P" | "M" | "G";
+    imgBase64: string;
+    withIcon: boolean;
+    username: string;
+}, {}>;
+export default _default;

package/dist/BaseDynamicLayerView2D-6ed632c7.js

@@ -0,0 +1,63 @@
+import { i as p, s, e as r, y as o, c as m } from "./index-a450f76b.js";
+import { a as h } from "./BitmapContainer-ac2e261c.js";
+import { m as n, u as d } from "./LayerView-2a8c8edc.js";
+import { v as c } from "./ExportStrategy-a42be397.js";
+import { i as u } from "./RefreshableLayerView-19c8ff47.js";
+import "vue";
+import "./WGLContainer-f4c4a8dc.js";
+import "./definitions-a00a3a6c.js";
+import "./LabelMetric-a3f892e4.js";
+import "./enums-2c166c09.js";
+import "./enums-fa8f05ab.js";
+import "./Texture-08e8abdd.js";
+import "./Program-5b5c8288.js";
+import "./BufferObject-faafd842.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./VertexArrayObject-4c6a6897.js";
+import "./vec4f32-b2628ced.js";
+import "./ProgramTemplate-62d54e1b.js";
+import "./Container-879e59ef.js";
+import "./parser-54b64f9a.js";
+import "./highlightReasons-23d6c956.js";
+import "./StyleDefinition-f4862d5a.js";
+import "./config-61215215.js";
+import "./earcut-1a1bdd2c.js";
+import "./featureConversionUtils-8635d4bd.js";
+import "./OptimizedGeometry-3b808152.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./scaleUtils-7e908168.js";
+import "./Bitmap-625c3ae1.js";
+let t = class extends u(n(d)) {
+  update(e) {
+    this._strategy.update(e).catch((i) => {
+      p(i) || s.getLogger(this).error(i);
+    }), this.notifyChange("updating");
+  }
+  attach() {
+    this._bitmapContainer = new h(), this.container.addChild(this._bitmapContainer), this._strategy = new c({ container: this._bitmapContainer, fetchSource: this.fetchBitmapData.bind(this), requestUpdate: this.requestUpdate.bind(this) });
+  }
+  detach() {
+    this._strategy.destroy(), this._strategy = null, this.container.removeChild(this._bitmapContainer), this._bitmapContainer.removeAllChildren();
+  }
+  moveStart() {
+  }
+  viewChange() {
+  }
+  moveEnd() {
+    this.requestUpdate();
+  }
+  fetchBitmapData(e, i, a) {
+    return this.layer.fetchImageBitmap(e, i, a);
+  }
+  async doRefresh() {
+    this.requestUpdate();
+  }
+  isUpdating() {
+    return this._strategy.updating || this.updateRequested;
+  }
+};
+r([o()], t.prototype, "_strategy", void 0), r([o()], t.prototype, "updating", void 0), t = r([m("esri.views.2d.layers.BaseDynamicLayerView2D")], t);
+const K = t;
+export {
+  K as default
+};

package/dist/BingMapsLayer-1b540400.js

@@ -0,0 +1,112 @@
+import { cZ as b, bR as c, b3 as j, aG as x, U as h, W as u, e as r, y as o, c as M, fu as U, a_ as B, bu as R, a$ as P, eg as a } from "./index-a450f76b.js";
+import { m as $ } from "./MultiOriginJSONSupport-677c0e5f.js";
+import { n as T } from "./BlendLayer-38d68343.js";
+import { f as k } from "./RefreshableLayer-0d1a28eb.js";
+import { t as _ } from "./ScaleRangeLayer-d06647e5.js";
+import { o as f } from "./imageBitmapUtils-12016538.js";
+import { u as I } from "./OperationalLayer-96cb1405.js";
+import "vue";
+import "./jsonUtils-599f89fd.js";
+import "./parser-54b64f9a.js";
+import "./commonProperties-7d8f6b56.js";
+import "./ElevationInfo-016cc1c4.js";
+import "./unitConversionUtils-ad9151e0.js";
+import "./lengthUtils-15c44621.js";
+var v;
+const y = new U("0/0/0", 0, 0, 0, void 0);
+let g = v = class extends T(_(k(B))) {
+  constructor() {
+    super(...arguments), this.tileInfo = b.create({ spatialReference: c.WebMercator, size: 256 }), this.type = "base-tile", this.fullExtent = new j(-20037508342787e-6, -2003750834278e-5, 2003750834278e-5, 20037508342787e-6, c.WebMercator), this.spatialReference = c.WebMercator;
+  }
+  getTileBounds(e, t, i, l) {
+    const n = l || x();
+    return y.level = e, y.row = t, y.col = i, y.extent = n, this.tileInfo.updateTileInfo(y), y.extent = void 0, n;
+  }
+  fetchTile(e, t, i, l = {}) {
+    const { signal: n } = l, p = this.getTileUrl(e, t, i), d = { responseType: "image", signal: n, query: { ...this.refreshParameters } };
+    return h(p ?? "", d).then((m) => m.data);
+  }
+  async fetchImageBitmapTile(e, t, i, l = {}) {
+    const { signal: n } = l;
+    if (this.fetchTile !== v.prototype.fetchTile) {
+      const S = await this.fetchTile(e, t, i, l);
+      return f(S, e, t, i, n);
+    }
+    const p = this.getTileUrl(e, t, i) ?? "", d = { responseType: "blob", signal: n, query: { ...this.refreshParameters } }, { data: m } = await h(p, d);
+    return f(m, e, t, i, n);
+  }
+  getTileUrl() {
+    throw new u("basetilelayer:gettileurl-not-implemented", "getTileUrl() is not implemented");
+  }
+};
+r([o({ type: b })], g.prototype, "tileInfo", void 0), r([o({ type: ["show", "hide"] })], g.prototype, "listMode", void 0), r([o({ readOnly: !0, value: "base-tile" })], g.prototype, "type", void 0), r([o({ nonNullable: !0 })], g.prototype, "fullExtent", void 0), r([o()], g.prototype, "spatialReference", void 0), g = v = r([M("esri.layers.BaseTileLayer")], g);
+const L = g, w = new R({ BingMapsAerial: "aerial", BingMapsRoad: "road", BingMapsHybrid: "hybrid" }), A = "https://dev.virtualearth.net";
+let s = class extends T(I($(L))) {
+  constructor(e) {
+    super(e), this.type = "bing-maps", this.tileInfo = new b({ size: [256, 256], dpi: 96, origin: new P({ x: -20037508342787e-6, y: 20037508342787e-6, spatialReference: c.WebMercator }), spatialReference: c.WebMercator, lods: [new a({ level: 1, resolution: 78271.5169639999, scale: 295828763795777e-6 }), new a({ level: 2, resolution: 39135.7584820001, scale: 147914381897889e-6 }), new a({ level: 3, resolution: 19567.8792409999, scale: 73957190948944e-6 }), new a({ level: 4, resolution: 9783.93962049996, scale: 36978595474472e-6 }), new a({ level: 5, resolution: 4891.96981024998, scale: 18489297737236e-6 }), new a({ level: 6, resolution: 2445.98490512499, scale: 9244648868618e-6 }), new a({ level: 7, resolution: 1222.99245256249, scale: 4622324434309e-6 }), new a({ level: 8, resolution: 611.49622628138, scale: 2311162217155e-6 }), new a({ level: 9, resolution: 305.748113140558, scale: 1155581108577e-6 }), new a({ level: 10, resolution: 152.874056570411, scale: 577790.554289 }), new a({ level: 11, resolution: 76.4370282850732, scale: 288895.277144 }), new a({ level: 12, resolution: 38.2185141425366, scale: 144447.638572 }), new a({ level: 13, resolution: 19.1092570712683, scale: 72223.819286 }), new a({ level: 14, resolution: 9.55462853563415, scale: 36111.909643 }), new a({ level: 15, resolution: 4.77731426794937, scale: 18055.954822 }), new a({ level: 16, resolution: 2.38865713397468, scale: 9027.977411 }), new a({ level: 17, resolution: 1.19432856685505, scale: 4513.988705 }), new a({ level: 18, resolution: 0.597164283559817, scale: 2256.994353 }), new a({ level: 19, resolution: 0.298582141647617, scale: 1128.497176 }), new a({ level: 20, resolution: 0.1492910708238085, scale: 564.248588 })] }), this.key = null, this.style = "road", this.culture = "en-US", this.region = null, this.portalUrl = null, this.hasAttributionData = !0;
+  }
+  get bingMetadata() {
+    return this._get("bingMetadata");
+  }
+  set bingMetadata(e) {
+    this._set("bingMetadata", e);
+  }
+  get copyright() {
+    return this.bingMetadata != null ? this.bingMetadata.copyright : null;
+  }
+  get operationalLayerType() {
+    return w.toJSON(this.style);
+  }
+  get bingLogo() {
+    return this.bingMetadata != null ? this.bingMetadata.brandLogoUri : null;
+  }
+  load(e) {
+    return this.key ? this.addResolvingPromise(this._getMetadata()) : this.portalUrl ? this.addResolvingPromise(this._getPortalBingKey().then(() => this._getMetadata())) : this.addResolvingPromise(Promise.reject(new u("bingmapslayer:load", "Bing layer must have bing key."))), Promise.resolve(this);
+  }
+  getTileUrl(e, t, i) {
+    if (!this.loaded || this.bingMetadata == null)
+      return null;
+    const l = this.bingMetadata.resourceSets[0].resources[0], n = l.imageUrlSubdomains[t % l.imageUrlSubdomains.length], p = this._getQuadKey(e, t, i);
+    return l.imageUrl.replace("{subdomain}", n).replace("{quadkey}", p);
+  }
+  async fetchAttributionData() {
+    return this.load().then(() => this.bingMetadata == null ? null : { contributors: this.bingMetadata.resourceSets[0].resources[0].imageryProviders.map((e) => ({ attribution: e.attribution, coverageAreas: e.coverageAreas.map((t) => ({ zoomMin: t.zoomMin, zoomMax: t.zoomMax, score: 1, bbox: [t.bbox[0], t.bbox[1], t.bbox[2], t.bbox[3]] })) })) });
+  }
+  _getMetadata() {
+    const e = { road: "roadOnDemand", aerial: "aerial", hybrid: "aerialWithLabelsOnDemand" }[this.style];
+    return h(`${A}/REST/v1/Imagery/Metadata/${e}`, { responseType: "json", query: { include: "ImageryProviders", uriScheme: "https", key: this.key, suppressStatus: !0, output: "json", culture: this.culture, userRegion: this.region } }).then((t) => {
+      const i = t.data;
+      if (i.statusCode !== 200)
+        throw new u("bingmapslayer:getmetadata", i.statusDescription);
+      if (this.bingMetadata = i, this.bingMetadata.resourceSets.length === 0)
+        throw new u("bingmapslayer:getmetadata", "no bing resourcesets");
+      if (this.bingMetadata.resourceSets[0].resources.length === 0)
+        throw new u("bingmapslayer:getmetadata", "no bing resources");
+    }).catch((t) => {
+      throw new u("bingmapslayer:getmetadata", t.message);
+    });
+  }
+  _getPortalBingKey() {
+    return h(this.portalUrl ?? "", { responseType: "json", authMode: "no-prompt", query: { f: "json" } }).then((e) => {
+      if (!e.data.bingKey)
+        throw new u("bingmapslayer:getportalbingkey", "The referenced Portal does not contain a valid bing key");
+      this.key = e.data.bingKey;
+    }).catch((e) => {
+      throw new u("bingmapslayer:getportalbingkey", e.message);
+    });
+  }
+  _getQuadKey(e, t, i) {
+    let l = "";
+    for (let n = e; n > 0; n--) {
+      let p = 0;
+      const d = 1 << n - 1;
+      i & d && (p += 1), t & d && (p += 2), l += p.toString();
+    }
+    return l;
+  }
+};
+r([o({ json: { read: !1, write: !1 }, value: null })], s.prototype, "bingMetadata", null), r([o({ json: { read: !1, write: !1 }, value: "bing-maps", readOnly: !0 })], s.prototype, "type", void 0), r([o({ type: b })], s.prototype, "tileInfo", void 0), r([o({ type: String, readOnly: !0, json: { read: !1, write: !1 } })], s.prototype, "copyright", null), r([o({ type: String, json: { write: !1, read: !1 } })], s.prototype, "key", void 0), r([o({ type: w.apiValues, nonNullable: !0, json: { read: { source: "layerType", reader: w.read } } })], s.prototype, "style", void 0), r([o({ type: ["BingMapsAerial", "BingMapsHybrid", "BingMapsRoad"] })], s.prototype, "operationalLayerType", null), r([o({ type: String, json: { write: !1, read: !1 } })], s.prototype, "culture", void 0), r([o({ type: String, json: { write: !1, read: !1 } })], s.prototype, "region", void 0), r([o({ type: String, json: { write: !0, read: !0 } })], s.prototype, "portalUrl", void 0), r([o({ type: Boolean, json: { write: !1, read: !1 } })], s.prototype, "hasAttributionData", void 0), r([o({ type: String, readOnly: !0 })], s.prototype, "bingLogo", null), s = r([M("esri.layers.BingMapsLayer")], s);
+const Z = s;
+export {
+  Z as default
+};

package/dist/Bitmap-625c3ae1.js

@@ -0,0 +1,128 @@
+import { dO as p, f5 as c, f6 as x, f7 as u, f8 as a, f9 as _, fa as g, fb as f, fc as m, fd as w } from "./index-a450f76b.js";
+import { i as B } from "./Container-879e59ef.js";
+import { P as k, G as R, D as S } from "./enums-2c166c09.js";
+import { e as b, m as v } from "./Texture-08e8abdd.js";
+class y {
+  constructor(t, e, i) {
+    this.pixelBlock = t, this.extent = e, this.originalPixelBlock = i;
+  }
+  get width() {
+    return this.pixelBlock != null ? this.pixelBlock.width : 0;
+  }
+  get height() {
+    return this.pixelBlock != null ? this.pixelBlock.height : 0;
+  }
+  render(t) {
+    const e = this.pixelBlock;
+    if (e == null)
+      return;
+    const i = this.filter({ extent: this.extent, pixelBlock: this.originalPixelBlock ?? e });
+    if (i.pixelBlock == null)
+      return;
+    i.pixelBlock.maskIsAlpha && (i.pixelBlock.premultiplyAlpha = !0);
+    const r = i.pixelBlock.getAsRGBA(), h = t.createImageData(i.pixelBlock.width, i.pixelBlock.height);
+    h.data.set(r), t.putImageData(h, 0, 0);
+  }
+  getRenderedRasterPixels() {
+    const t = this.filter({ extent: this.extent, pixelBlock: this.pixelBlock });
+    return t.pixelBlock == null ? null : (t.pixelBlock.maskIsAlpha && (t.pixelBlock.premultiplyAlpha = !0), { width: t.pixelBlock.width, height: t.pixelBlock.height, renderedRasterPixels: new Uint8Array(t.pixelBlock.getAsRGBA().buffer) });
+  }
+}
+function T(s) {
+  return s && "render" in s;
+}
+function A(s) {
+  const t = document.createElement("canvas");
+  return t.width = s.width, t.height = s.height, s.render(t.getContext("2d")), t;
+}
+function M(s) {
+  var t;
+  return T(s) ? s instanceof y ? (t = s.getRenderedRasterPixels()) == null ? void 0 : t.renderedRasterPixels : A(s) : s;
+}
+class G extends B {
+  constructor(t = null, e = !1) {
+    super(), this.blendFunction = "standard", this._sourceWidth = 0, this._sourceHeight = 0, this._textureInvalidated = !1, this._texture = null, this.stencilRef = 0, this.coordScale = [1, 1], this._height = void 0, this.pixelRatio = 1, this.resolution = 0, this.rotation = 0, this._source = null, this._width = void 0, this.x = 0, this.y = 0, this.immutable = e, this.source = t, this.requestRender = this.requestRender.bind(this);
+  }
+  destroy() {
+    this._texture && (this._texture.dispose(), this._texture = null), this._uploadStatus != null && (this._uploadStatus.controller.abort(), this._uploadStatus = null);
+  }
+  get isSourceScaled() {
+    return this.width !== this._sourceWidth || this.height !== this._sourceHeight;
+  }
+  get height() {
+    return this._height !== void 0 ? this._height : this._sourceHeight;
+  }
+  set height(t) {
+    this._height = t;
+  }
+  get source() {
+    return this._source;
+  }
+  set source(t) {
+    t == null && this._source == null || (this._source = t, this.invalidateTexture(), this.requestRender());
+  }
+  get width() {
+    return this._width !== void 0 ? this._width : this._sourceWidth;
+  }
+  set width(t) {
+    this._width = t;
+  }
+  beforeRender(t) {
+    super.beforeRender(t), this.updateTexture(t);
+  }
+  async setSourceAsync(t, e) {
+    this._uploadStatus != null && this._uploadStatus.controller.abort();
+    const i = new AbortController(), r = p();
+    return c(e, () => i.abort()), c(i, (h) => r.reject(h)), this._uploadStatus = { controller: i, resolver: r }, this.source = t, r.promise;
+  }
+  invalidateTexture() {
+    this._textureInvalidated || (this._textureInvalidated = !0, this._source instanceof HTMLImageElement ? (this._sourceHeight = this._source.naturalHeight, this._sourceWidth = this._source.naturalWidth) : this._source && (this._sourceHeight = this._source.height, this._sourceWidth = this._source.width));
+  }
+  updateTransitionProperties(t, e) {
+    t >= 64 && (this.fadeTransitionEnabled = !1, this.inFadeTransition = !1), super.updateTransitionProperties(t, e);
+  }
+  setTransform(t) {
+    const e = x(this.transforms.displayViewScreenMat3), [i, r] = t.toScreenNoRotation([0, 0], [this.x, this.y]), h = this.resolution / this.pixelRatio / t.resolution, o = h * this.width, l = h * this.height, n = Math.PI * this.rotation / 180;
+    u(e, e, a(i, r)), u(e, e, a(o / 2, l / 2)), _(e, e, -n), u(e, e, a(-o / 2, -l / 2)), g(e, e, a(o, l)), f(this.transforms.displayViewScreenMat3, t.displayViewMat3, e);
+  }
+  setSamplingProfile(t) {
+    this._texture && (t.mips && !this._texture.descriptor.hasMipmap && this._texture.generateMipmap(), this._texture.setSamplingMode(t.samplingMode));
+  }
+  bind(t, e) {
+    this._texture && t.bindTexture(this._texture, e);
+  }
+  async updateTexture({ context: t, painter: e }) {
+    if (!this._textureInvalidated)
+      return;
+    if (this._textureInvalidated = !1, this._texture || (this._texture = this._createTexture(t)), !this.source)
+      return void this._texture.setData(null);
+    this._texture.resize(this._sourceWidth, this._sourceHeight);
+    const i = M(this.source);
+    try {
+      if (this._uploadStatus != null) {
+        const { controller: r, resolver: h } = this._uploadStatus, o = { signal: r.signal }, { width: l, height: n } = this, d = this._texture;
+        await e.textureUploadManager.enqueueTextureUpdate({ data: i, texture: d, width: l, height: n }, o), h.resolve(), this._uploadStatus = null;
+      } else
+        this._texture.setData(i);
+      this.ready();
+    } catch (r) {
+      m(r);
+    }
+  }
+  onDetach() {
+    this.destroy();
+  }
+  _createTransforms() {
+    return { displayViewScreenMat3: w() };
+  }
+  _createTexture(t) {
+    const e = this.immutable, i = new b();
+    return i.internalFormat = e ? k.RGBA8 : R.RGBA, i.wrapMode = S.CLAMP_TO_EDGE, i.isImmutable = e, i.width = this._sourceWidth, i.height = this._sourceHeight, new v(t, i);
+  }
+}
+export {
+  G as b,
+  A as f,
+  T as g,
+  y as l
+};

package/dist/BitmapContainer-ac2e261c.js

@@ -0,0 +1,23 @@
+import { n as s, h as a } from "./WGLContainer-f4c4a8dc.js";
+import { E as t } from "./Container-879e59ef.js";
+class h extends s {
+  constructor() {
+    super(...arguments), this._hasCrossfade = !1;
+  }
+  get requiresDedicatedFBO() {
+    return super.requiresDedicatedFBO || this._hasCrossfade;
+  }
+  beforeRender(e) {
+    super.beforeRender(e), this._manageFade();
+  }
+  prepareRenderPasses(e) {
+    const r = e.registerRenderPass({ name: "bitmap", brushes: [a.bitmap], target: () => this.children, drawPhase: t.MAP });
+    return [...super.prepareRenderPasses(e), r];
+  }
+  _manageFade() {
+    this.children.reduce((e, r) => e + (r.inFadeTransition ? 1 : 0), 0) >= 2 ? (this.children.forEach((e) => e.blendFunction = "additive"), this._hasCrossfade = !0) : (this.children.forEach((e) => e.blendFunction = "standard"), this._hasCrossfade = !1);
+  }
+}
+export {
+  h as a
+};

package/dist/BlendLayer-38d68343.js

@@ -0,0 +1,13 @@
+import { e as r, y as t, c as n } from "./index-a450f76b.js";
+import { n as l, a } from "./jsonUtils-599f89fd.js";
+const o = { read: { reader: l }, write: { allowNull: !0, writer: a } }, u = (i) => {
+  let e = class extends i {
+    constructor() {
+      super(...arguments), this.blendMode = "normal", this.effect = null;
+    }
+  };
+  return r([t({ type: ["average", "color-burn", "color-dodge", "color", "darken", "destination-atop", "destination-in", "destination-out", "destination-over", "difference", "exclusion", "hard-light", "hue", "invert", "lighten", "lighter", "luminosity", "minus", "multiply", "normal", "overlay", "plus", "reflect", "saturation", "screen", "soft-light", "source-atop", "source-in", "source-out", "vivid-light", "xor"], nonNullable: !0, json: { read: !1, write: !1, origins: { "web-map": { read: !0, write: !0 }, "portal-item": { read: !0, write: !0 } } } })], e.prototype, "blendMode", void 0), r([t({ json: { read: !1, write: !1, origins: { "web-map": o, "portal-item": o } } })], e.prototype, "effect", void 0), e = r([n("esri.layers.mixins.BlendLayer")], e), e;
+};
+export {
+  u as n
+};

package/dist/BoundsStore-f1942e67.js

@@ -0,0 +1,63 @@
+import { aO as o, de as h } from "./index-a450f76b.js";
+import { s as a } from "./PooledRBush-af918d48.js";
+const _ = 5e4, t = { minX: 0, minY: 0, maxX: 0, maxY: 0 };
+function u(i) {
+  t.minX = i[0], t.minY = i[1], t.maxX = i[2], t.maxY = i[3];
+}
+function l(i, s, d) {
+  u(s), i.search(t, d);
+}
+class B {
+  constructor() {
+    this._indexInvalid = !1, this._boundsToLoad = [], this._boundsById = /* @__PURE__ */ new Map(), this._idByBounds = /* @__PURE__ */ new Map(), this._index = new a(9, o("esri-csp-restrictions") ? (s) => ({ minX: s[0], minY: s[1], maxX: s[2], maxY: s[3] }) : ["[0]", "[1]", "[2]", "[3]"]), this._loadIndex = () => {
+      if (this._indexInvalid) {
+        const s = new Array(this._idByBounds.size);
+        let d = 0;
+        this._idByBounds.forEach((n, e) => {
+          s[d++] = e;
+        }), this._indexInvalid = !1, this._index.clear(), this._index.load(s);
+      } else
+        this._boundsToLoad.length && (this._index.load(Array.from(new Set(this._boundsToLoad.filter((s) => this._idByBounds.has(s))))), this._boundsToLoad.length = 0);
+    };
+  }
+  get fullBounds() {
+    if (!this._boundsById.size)
+      return null;
+    const s = h();
+    for (const d of this._boundsById.values())
+      d && (s[0] = Math.min(d[0], s[0]), s[1] = Math.min(d[1], s[1]), s[2] = Math.max(d[2], s[2]), s[3] = Math.max(d[3], s[3]));
+    return s;
+  }
+  get valid() {
+    return !this._indexInvalid;
+  }
+  clear() {
+    this._indexInvalid = !1, this._boundsToLoad.length = 0, this._boundsById.clear(), this._idByBounds.clear(), this._index.clear();
+  }
+  delete(s) {
+    const d = this._boundsById.get(s);
+    this._boundsById.delete(s), d && (this._idByBounds.delete(d), this._indexInvalid || this._index.remove(d));
+  }
+  forEachInBounds(s, d) {
+    this._loadIndex(), l(this._index, s, (n) => d(this._idByBounds.get(n)));
+  }
+  get(s) {
+    return this._boundsById.get(s);
+  }
+  has(s) {
+    return this._boundsById.has(s);
+  }
+  invalidateIndex() {
+    this._indexInvalid || (this._indexInvalid = !0, this._boundsToLoad.length = 0);
+  }
+  set(s, d) {
+    if (!this._indexInvalid) {
+      const n = this._boundsById.get(s);
+      n && (this._index.remove(n), this._idByBounds.delete(n));
+    }
+    this._boundsById.set(s, d), d && (this._idByBounds.set(d, s), this._indexInvalid || (this._boundsToLoad.push(d), this._boundsToLoad.length > _ && this._loadIndex()));
+  }
+}
+export {
+  B as o
+};

package/dist/BufferObject-faafd842.js

@@ -0,0 +1,100 @@
+import { L as R, M as A, N as b, s as l } from "./index-a450f76b.js";
+import { u as h } from "./Texture-08e8abdd.js";
+import { A as r, F as o, V as E, C as f } from "./enums-2c166c09.js";
+const n = () => l.getLogger("esri.views.webgl.BufferObject");
+let T = class a {
+  static createIndex(t, e, s) {
+    return new a(t, r.ELEMENT_ARRAY_BUFFER, e, s);
+  }
+  static createVertex(t, e, s) {
+    return new a(t, r.ARRAY_BUFFER, e, s);
+  }
+  static createUniform(t, e, s) {
+    return new a(t, r.UNIFORM_BUFFER, e, s);
+  }
+  static createPixelPack(t, e = o.STREAM_READ, s) {
+    const i = new a(t, r.PIXEL_PACK_BUFFER, e);
+    return s && i.setSize(s), i;
+  }
+  static createPixelUnpack(t, e = o.STREAM_DRAW, s) {
+    return new a(t, r.PIXEL_UNPACK_BUFFER, e, s);
+  }
+  static createTransformFeedback(t, e = o.STATIC_DRAW, s) {
+    const i = new a(t, r.TRANSFORM_FEEDBACK_BUFFER, e);
+    return i.setSize(s), i;
+  }
+  constructor(t, e, s, i) {
+    this._context = t, this.bufferType = e, this.usage = s, this._glName = null, this._size = -1, this._indexType = void 0, t.instanceCounter.increment(E.BufferObject, this), this._glName = this._context.gl.createBuffer(), h(this._context.gl), i && this.setData(i);
+  }
+  get glName() {
+    return this._glName;
+  }
+  get size() {
+    return this._size;
+  }
+  get indexType() {
+    return this._indexType;
+  }
+  get usedMemory() {
+    return this.bufferType === r.ELEMENT_ARRAY_BUFFER ? this._indexType === f.UNSIGNED_INT ? 4 * this._size : 2 * this._size : this._size;
+  }
+  get _isVAOAware() {
+    return this.bufferType === r.ELEMENT_ARRAY_BUFFER || this.bufferType === r.ARRAY_BUFFER;
+  }
+  dispose() {
+    var t;
+    (t = this._context) != null && t.gl ? (this._glName && (this._context.gl.deleteBuffer(this._glName), this._glName = null), this._context.instanceCounter.decrement(E.BufferObject, this), this._context = null) : this._glName && n().warn("Leaked WebGL buffer object");
+  }
+  setSize(t, e = null) {
+    if (t <= 0 && n().error("Buffer size needs to be positive!"), this.bufferType === r.ELEMENT_ARRAY_BUFFER && e != null)
+      switch (this._indexType = e, e) {
+        case f.UNSIGNED_SHORT:
+          t *= 2;
+          break;
+        case f.UNSIGNED_INT:
+          t *= 4;
+      }
+    this._setBufferData(t);
+  }
+  setData(t) {
+    if (!t)
+      return;
+    let e = t.byteLength;
+    this.bufferType === r.ELEMENT_ARRAY_BUFFER && (R(t) && (e /= 2, this._indexType = f.UNSIGNED_SHORT), A(t) && (e /= 4, this._indexType = f.UNSIGNED_INT)), this._setBufferData(e, t);
+  }
+  _setBufferData(t, e = null) {
+    this._size = t;
+    const s = this._context.getBoundVAO();
+    this._isVAOAware && this._context.bindVAO(null), this._context.bindBuffer(this);
+    const i = this._context.gl;
+    e != null ? i.bufferData(this.bufferType, e, this.usage) : i.bufferData(this.bufferType, t, this.usage), h(i), this._isVAOAware && this._context.bindVAO(s);
+  }
+  setSubData(t, e, s, i) {
+    if (!t)
+      return;
+    (e < 0 || e * t.BYTES_PER_ELEMENT >= this.usedMemory) && n().error("offset is out of range!"), s >= i && n().error("end must be bigger than start!"), (e + (i - s)) * t.BYTES_PER_ELEMENT > this.usedMemory && n().error("An attempt to write beyond the end of the buffer!");
+    const u = this._context.getBoundVAO();
+    this._isVAOAware && this._context.bindVAO(null), this._context.bindBuffer(this);
+    const { gl: _ } = this._context;
+    _.bufferSubData(this.bufferType, e * t.BYTES_PER_ELEMENT, t, s, i - s), h(_), this._isVAOAware && this._context.bindVAO(u);
+  }
+  getSubData(t, e = 0, s, i) {
+    if (s < 0 || i < 0)
+      return void n().error("Problem getting subdata: offset and length were less than zero!");
+    const u = F(t) ? t.BYTES_PER_ELEMENT : 1;
+    if (u * ((s ?? 0) + (i ?? 0)) > t.byteLength)
+      return void n().error("Problem getting subdata: offset and length exceeded destination size!");
+    e + u * (i ?? 0) > this.usedMemory && n().warn("Potential problem getting subdata: requested data exceeds buffer size!");
+    const _ = this._context.gl;
+    this.bufferType === r.TRANSFORM_FEEDBACK_BUFFER ? (this._context.bindBuffer(this, r.TRANSFORM_FEEDBACK_BUFFER), _.getBufferSubData(r.TRANSFORM_FEEDBACK_BUFFER, e, t, s, i), this._context.unbindBuffer(r.TRANSFORM_FEEDBACK_BUFFER)) : (this._context.bindBuffer(this, r.COPY_READ_BUFFER), _.getBufferSubData(r.COPY_READ_BUFFER, e, t, s, i), this._context.unbindBuffer(r.COPY_READ_BUFFER));
+  }
+  async getSubDataAsync(t, e = 0, s, i) {
+    await this._context.clientWaitAsync(), this.getSubData(t, e, s, i);
+  }
+};
+function F(c) {
+  return b(c);
+}
+export {
+  T as h
+};