@agrotools1/at-components 0.3.5 → 0.3.6

package/dist/InterleavedLayout-c4731d7d.js

@@ -0,0 +1,163 @@
+import { y as l, u as o, i as a, c as p, l as c, p as _, o as y, m as F, T as m, h as g, a as w, b, d as v, A as E, O as z, x as A, g as T, w as H, E as I, L as M, B as $, F as O, I as k, U as D, j as B, V as C, M as G, S as V, k as j, q as L, v as q, z as J, C as K, D as N, G as S, H as P } from "./BufferView-96849449.js";
+import { e as f } from "./types-adba9034.js";
+import { s as Q } from "./Util-04115b51.js";
+class h {
+  constructor(t, e) {
+    this.layout = t, this.buffer = typeof e == "number" ? new ArrayBuffer(e * t.stride) : e;
+    for (const s of t.fields.keys()) {
+      const i = t.fields.get(s);
+      this[s] = new i.constructor(this.buffer, i.offset, this.stride);
+    }
+  }
+  get stride() {
+    return this.layout.stride;
+  }
+  get count() {
+    return this.buffer.byteLength / this.stride;
+  }
+  get byteLength() {
+    return this.buffer.byteLength;
+  }
+  getField(t, e) {
+    const s = this[t];
+    return s && s.elementCount === e.ElementCount && s.elementType === e.ElementType ? s : null;
+  }
+  slice(t, e) {
+    return new h(this.layout, this.buffer.slice(t * this.stride, e * this.stride));
+  }
+  copyFrom(t, e = 0, s = 0, i = t.count) {
+    const r = this.stride;
+    if (r % 4 == 0) {
+      const d = new Uint32Array(t.buffer, e * r, i * r / 4);
+      new Uint32Array(this.buffer, s * r, i * r / 4).set(d);
+    } else {
+      const d = new Uint8Array(t.buffer, e * r, i * r);
+      new Uint8Array(this.buffer, s * r, i * r).set(d);
+    }
+    return this;
+  }
+  get usedMemory() {
+    return this.byteLength;
+  }
+  dispose() {
+  }
+}
+class u {
+  constructor(t = null) {
+    this._stride = 0, this._lastAligned = 0, this._fields = /* @__PURE__ */ new Map(), t && (this._stride = t.stride, t.fields.forEach((e) => this._fields.set(e[0], { ...e[1], constructor: W(e[1].constructor) })));
+  }
+  vec2f(t, e) {
+    return this._appendField(t, o, e), this;
+  }
+  vec2f64(t, e) {
+    return this._appendField(t, F, e), this;
+  }
+  vec3f(t, e) {
+    return this._appendField(t, a, e), this;
+  }
+  vec3f64(t, e) {
+    return this._appendField(t, m, e), this;
+  }
+  vec4f(t, e) {
+    return this._appendField(t, p, e), this;
+  }
+  vec4f64(t, e) {
+    return this._appendField(t, g, e), this;
+  }
+  mat3f(t, e) {
+    return this._appendField(t, c, e), this;
+  }
+  mat3f64(t, e) {
+    return this._appendField(t, w, e), this;
+  }
+  mat4f(t, e) {
+    return this._appendField(t, _, e), this;
+  }
+  mat4f64(t, e) {
+    return this._appendField(t, b, e), this;
+  }
+  vec4u8(t, e) {
+    return this._appendField(t, A, e), this;
+  }
+  f32(t, e) {
+    return this._appendField(t, l, e), this;
+  }
+  f64(t, e) {
+    return this._appendField(t, y, e), this;
+  }
+  u8(t, e) {
+    return this._appendField(t, v, e), this;
+  }
+  u16(t, e) {
+    return this._appendField(t, T, e), this;
+  }
+  i8(t, e) {
+    return this._appendField(t, B, e), this;
+  }
+  vec2i8(t, e) {
+    return this._appendField(t, C, e), this;
+  }
+  vec2i16(t, e) {
+    return this._appendField(t, L, e), this;
+  }
+  vec2u8(t, e) {
+    return this._appendField(t, E, e), this;
+  }
+  vec4u16(t, e) {
+    return this._appendField(t, M, e), this;
+  }
+  u32(t, e) {
+    return this._appendField(t, $, e), this;
+  }
+  _appendField(t, e, s) {
+    if (this._fields.has(t))
+      return void Q(!1, `${t} already added to vertex buffer layout`);
+    const i = e.ElementCount * f(e.ElementType), r = this._stride;
+    this._stride += i, this._fields.set(t, { size: i, constructor: e, offset: r, optional: s });
+  }
+  createBuffer(t) {
+    return new h(this, t);
+  }
+  createView(t) {
+    return new h(this, t);
+  }
+  clone() {
+    const t = new u();
+    return t._stride = this._stride, t._fields = /* @__PURE__ */ new Map(), this._fields.forEach((e, s) => t._fields.set(s, e)), t.BufferType = this.BufferType, t;
+  }
+  get stride() {
+    if (this._lastAligned !== this._fields.size) {
+      let t = 1;
+      this._fields.forEach((e) => t = Math.max(t, f(e.constructor.ElementType))), this._stride = Math.floor((this._stride + t - 1) / t) * t, this._lastAligned = this._fields.size;
+    }
+    return this._stride;
+  }
+  get fields() {
+    return this._fields;
+  }
+}
+function tt() {
+  return new u();
+}
+class et {
+  constructor(t) {
+    this.fields = new Array(), t.fields.forEach((e, s) => {
+      const i = { ...e, constructor: U(e.constructor) };
+      this.fields.push([s, i]);
+    }), this.stride = t.stride;
+  }
+}
+const R = [l, o, a, p, c, _, y, F, m, g, w, b, v, E, z, A, T, H, I, M, $, O, k, D, B, C, G, V, j, L, q, J, K, N, S, P];
+function U(n) {
+  return `${n.ElementType}_${n.ElementCount}`;
+}
+function W(n) {
+  return x.get(n);
+}
+const x = /* @__PURE__ */ new Map();
+R.forEach((n) => x.set(U(n), n));
+export {
+  u as G,
+  tt as H,
+  et as I
+};

package/dist/KMLLayer-bc47cd3d.js

@@ -0,0 +1,162 @@
+import { dc as O, bi as _, H as c, eD as p, o as y, fH as v, b3 as d, c3 as F, V as b, e as r, y as l, fI as j, c5 as h, c as g, fy as M, cP as $, bR as S, d4 as I, bO as C, c2 as P, a_ as R } from "./index-4ead5b97.js";
+import { m as K } from "./MultiOriginJSONSupport-66a73b5d.js";
+import { n as N } from "./BlendLayer-f24275a8.js";
+import { u as T } from "./OperationalLayer-2e935984.js";
+import { j as H } from "./PortalLayer-15420854.js";
+import { f as J } from "./RefreshableLayer-f99ea584.js";
+import { t as z } from "./ScaleRangeLayer-6b36cfd2.js";
+import { d as A } from "./commonProperties-c36fc1b2.js";
+import { j as V, S as w, g as x, d as E } from "./kmlUtils-a32aa47a.js";
+import "vue";
+import "./jsonUtils-2a454e30.js";
+import "./parser-bab9c2ce.js";
+import "./portalItemUtils-9fe0753b.js";
+import "./ElevationInfo-c194d5f5.js";
+import "./unitConversionUtils-c6c847c9.js";
+import "./lengthUtils-21f99608.js";
+import "./jsonUtils-fbd6d2d1.js";
+import "./UniqueValueRenderer-cc2c9298.js";
+import "./ColorStop-6fd09765.js";
+import "./diffUtils-f967bb01.js";
+import "./colorRamps-fedcdeb0.js";
+import "./sizeVariableUtils-a1b694d8.js";
+import "./visualVariableUtils-88773652.js";
+import "./jsonUtils-0c0893e4.js";
+import "./styleUtils-b62393b9.js";
+import "./LRUCache-7a6c25d0.js";
+import "./MemCache-cfd09d4d.js";
+import "./Version-df01af53.js";
+import "./FieldsIndex-cddb2b35.js";
+import "./UnknownTimeZone-6d259a58.js";
+import "./OverrideHelper-212a5126.js";
+import "./colorUtils-b3dcdea1.js";
+import "./vec42-689e76ac.js";
+import "./vec4f64-043e974c.js";
+import "./utils-b1ab6c91.js";
+import "./quantizationUtils-2be4bff3.js";
+import "./heatmapUtils-ae60011e.js";
+import "./FeatureSet-a2d35655.js";
+var u;
+let a = u = class extends O.EventedMixin(_(M)) {
+  constructor(...t) {
+    super(...t), this.description = null, this.fullExtent = null, this.id = null, this.networkLink = null, this.parent = null, this.sublayers = null, this.title = null, this.sourceJSON = null, this.layer = null, this.addHandles([c(() => this.sublayers, "after-add", ({ item: e }) => {
+      e.parent = this, e.layer = this.layer;
+    }, p), c(() => this.sublayers, "after-remove", ({ item: e }) => {
+      e.layer = e.parent = null;
+    }, p), y(() => this.sublayers, (e, s) => {
+      if (s)
+        for (const i of s)
+          i.layer = i.parent = null;
+      if (e)
+        for (const i of e)
+          i.parent = this, i.layer = this.layer;
+    }, p), y(() => this.layer, (e) => {
+      if (this.sublayers)
+        for (const s of this.sublayers)
+          s.layer = e;
+    }, p)]);
+  }
+  initialize() {
+    v(() => this.networkLink).then(() => v(() => this.visible === !0)).then(() => this.load());
+  }
+  load(t) {
+    var i;
+    if (!this.networkLink || this.networkLink.viewFormat)
+      return;
+    const e = t != null ? t.signal : null, s = this._fetchService(((i = this._get("networkLink")) == null ? void 0 : i.href) ?? "", e).then((n) => {
+      var f;
+      const L = V(n.sublayers);
+      this.fullExtent = d.fromJSON(L), this.sourceJSON = n;
+      const m = F(b.ofType(u), w(u, n));
+      this.sublayers ? this.sublayers.addMany(m) : this.sublayers = m, (f = this.layer) == null || f.emit("sublayer-update"), this.layer && this.layer.notifyChange("visibleSublayers");
+    });
+    return this.addResolvingPromise(s), Promise.resolve(this);
+  }
+  get visible() {
+    return this._get("visible");
+  }
+  set visible(t) {
+    this._get("visible") !== t && (this._set("visible", t), this.layer && this.layer.notifyChange("visibleSublayers"));
+  }
+  readVisible(t, e) {
+    return !!e.visibility;
+  }
+  _fetchService(t, e) {
+    return x(t, this.layer.outSpatialReference, this.layer.refreshInterval, e).then((s) => E(s.data));
+  }
+};
+r([l()], a.prototype, "description", void 0), r([l({ type: d })], a.prototype, "fullExtent", void 0), r([l()], a.prototype, "id", void 0), r([l({ readOnly: !0, value: null })], a.prototype, "networkLink", void 0), r([l({ json: { write: { allowNull: !0 } } })], a.prototype, "parent", void 0), r([l({ type: b.ofType(a), json: { write: { allowNull: !0 } } })], a.prototype, "sublayers", void 0), r([l({ value: null, json: { read: { source: "name", reader: (t) => j(t) } } })], a.prototype, "title", void 0), r([l({ value: !0 })], a.prototype, "visible", null), r([h("visible", ["visibility"])], a.prototype, "readVisible", null), r([l()], a.prototype, "sourceJSON", void 0), r([l()], a.prototype, "layer", void 0), a = u = r([g("esri.layers.support.KMLSublayer")], a);
+const k = a, W = ["kml", "xml"];
+let o = class extends N(J(z(T(H(K(R)))))) {
+  constructor(...t) {
+    super(...t), this._visibleFolders = [], this.allSublayers = new $({ getCollections: () => [this.sublayers], getChildrenFunction: (e) => e.sublayers }), this.outSpatialReference = S.WGS84, this.path = null, this.legendEnabled = !1, this.operationalLayerType = "KML", this.sublayers = null, this.type = "kml", this.url = null;
+  }
+  initialize() {
+    this.addHandles([y(() => this.sublayers, (t, e) => {
+      e && e.forEach((s) => {
+        s.parent = null, s.layer = null;
+      }), t && t.forEach((s) => {
+        s.parent = this, s.layer = this;
+      });
+    }, p), this.on("sublayer-update", () => this.notifyChange("fullExtent"))]);
+  }
+  normalizeCtorArgs(t, e) {
+    return typeof t == "string" ? { url: t, ...e } : t;
+  }
+  readSublayersFromItemOrWebMap(t, e) {
+    this._visibleFolders = e.visibleFolders;
+  }
+  readSublayers(t, e, s) {
+    return w(k, e, s, this._visibleFolders);
+  }
+  writeSublayers(t, e) {
+    const s = [], i = t.toArray();
+    for (; i.length; ) {
+      const n = i[0];
+      n.networkLink || (n.visible && s.push(n.id), n.sublayers && i.push(...n.sublayers.toArray())), i.shift();
+    }
+    e.visibleFolders = s;
+  }
+  get title() {
+    const t = this._get("title");
+    return t && this.originOf("title") !== "defaults" ? t : this.url ? I(this.url, W) || "KML" : t || "";
+  }
+  set title(t) {
+    this._set("title", t);
+  }
+  get visibleSublayers() {
+    const t = this.sublayers, e = [], s = (i) => {
+      i.visible && (e.push(i), i.sublayers && i.sublayers.forEach(s));
+    };
+    return t && t.forEach(s), e;
+  }
+  get fullExtent() {
+    return this._recomputeFullExtent();
+  }
+  load(t) {
+    const e = t != null ? t.signal : null;
+    return this.addResolvingPromise(this.loadFromPortal({ supportedTypes: ["KML"], supportsData: !1 }, t).catch(C).then(() => this._fetchService(e))), Promise.resolve(this);
+  }
+  destroy() {
+    super.destroy(), this.allSublayers.destroy();
+  }
+  async _fetchService(t) {
+    const e = await Promise.resolve().then(() => this.resourceInfo ? { ssl: !1, data: this.resourceInfo } : x(this.url ?? "", this.outSpatialReference, this.refreshInterval, t)), s = E(e.data);
+    s && this.read(s, { origin: "service" });
+  }
+  _recomputeFullExtent() {
+    let t = null;
+    this.extent != null && (t = this.extent.clone());
+    const e = (s) => {
+      if (s.sublayers)
+        for (const i of s.sublayers.items)
+          e(i), i.visible && i.fullExtent && (t != null ? t.union(i.fullExtent) : t = i.fullExtent.clone());
+    };
+    return e(this), t;
+  }
+};
+r([l({ readOnly: !0 })], o.prototype, "allSublayers", void 0), r([l({ type: S })], o.prototype, "outSpatialReference", void 0), r([l({ type: String, json: { origins: { "web-scene": { read: !0, write: !0 } }, read: !1 } })], o.prototype, "path", void 0), r([l({ readOnly: !0, json: { read: !1, write: !1 } })], o.prototype, "legendEnabled", void 0), r([l({ type: ["show", "hide", "hide-children"] })], o.prototype, "listMode", void 0), r([l({ type: ["KML"] })], o.prototype, "operationalLayerType", void 0), r([l({})], o.prototype, "resourceInfo", void 0), r([l({ type: b.ofType(k), json: { write: { ignoreOrigin: !0 } } })], o.prototype, "sublayers", void 0), r([h(["web-map", "portal-item"], "sublayers", ["visibleFolders"])], o.prototype, "readSublayersFromItemOrWebMap", null), r([h("service", "sublayers", ["sublayers"])], o.prototype, "readSublayers", null), r([P("sublayers")], o.prototype, "writeSublayers", null), r([l({ readOnly: !0, json: { read: !1 } })], o.prototype, "type", void 0), r([l({ json: { origins: { "web-map": { read: { source: "title" } } }, write: { ignoreOrigin: !0 } } })], o.prototype, "title", null), r([l(A)], o.prototype, "url", void 0), r([l({ readOnly: !0 })], o.prototype, "visibleSublayers", null), r([l({ type: d })], o.prototype, "extent", void 0), r([l()], o.prototype, "fullExtent", null), o = r([g("esri.layers.KMLLayer")], o);
+const jt = o;
+export {
+  jt as default
+};

package/dist/KMLLayerView2D-f2b1d389.js

@@ -0,0 +1,253 @@
+import { t as G, bT as T, a$ as k, U as z, d as D, V as F, o as O, a as N, x as C, b3 as U, cC as W, bR as $, eE as H, eF as A, c4 as K, eh as J, e as v, y as S, c as Y } from "./index-4ead5b97.js";
+import { b as P, g as Q, d as X } from "./kmlUtils-a32aa47a.js";
+import { g as Z, f as tt, b as et } from "./Bitmap-45982a38.js";
+import { a as it } from "./BitmapContainer-ae676ce9.js";
+import { m as at, u as st } from "./LayerView-3582efbb.js";
+import { t as M } from "./GraphicContainer-8f518c24.js";
+import { $ as R } from "./GraphicsView2D-4786cec0.js";
+import { C as rt, e as ot } from "./rasterProjectionHelper-29c41430.js";
+import { a as nt } from "./WGLContainer-ba3d390b.js";
+import { w as lt, o as pt } from "./RenderingContext-010afb99.js";
+import { D as E, G as ht, U as mt, X as L } from "./enums-2c166c09.js";
+import { x as ct } from "./Program-b10e4f81.js";
+import { c as dt } from "./rasterUtils-9175fa83.js";
+import { e as q, m as ut } from "./Texture-cb75240c.js";
+import "vue";
+import "./jsonUtils-fbd6d2d1.js";
+import "./UniqueValueRenderer-cc2c9298.js";
+import "./ColorStop-6fd09765.js";
+import "./diffUtils-f967bb01.js";
+import "./colorRamps-fedcdeb0.js";
+import "./sizeVariableUtils-a1b694d8.js";
+import "./visualVariableUtils-88773652.js";
+import "./lengthUtils-21f99608.js";
+import "./jsonUtils-0c0893e4.js";
+import "./styleUtils-b62393b9.js";
+import "./LRUCache-7a6c25d0.js";
+import "./MemCache-cfd09d4d.js";
+import "./Version-df01af53.js";
+import "./FieldsIndex-cddb2b35.js";
+import "./UnknownTimeZone-6d259a58.js";
+import "./OverrideHelper-212a5126.js";
+import "./colorUtils-b3dcdea1.js";
+import "./vec42-689e76ac.js";
+import "./vec4f64-043e974c.js";
+import "./utils-b1ab6c91.js";
+import "./quantizationUtils-2be4bff3.js";
+import "./heatmapUtils-ae60011e.js";
+import "./FeatureSet-a2d35655.js";
+import "./Container-d699fcb8.js";
+import "./parser-bab9c2ce.js";
+import "./highlightReasons-79f118f3.js";
+import "./definitions-a00a3a6c.js";
+import "./scaleUtils-0293f229.js";
+import "./AGraphicContainer-b156cbdc.js";
+import "./TechniqueInstance-34decb51.js";
+import "./UpdateTracking2D-f77879d5.js";
+import "./TurboLine-b4edfa68.js";
+import "./enums-fa8f05ab.js";
+import "./earcut-ae826f5c.js";
+import "./GeometryUtils-5c77f1b0.js";
+import "./OptimizedGeometry-3b808152.js";
+import "./Rect-894f011c.js";
+import "./LabelMetric-a5c60841.js";
+import "./VertexElementDescriptor-d7c718c2.js";
+import "./defaults-9d551b4c.js";
+import "./defaultsJSON-ba17aa15.js";
+import "./BindType-5e76c8e1.js";
+import "./Util-04115b51.js";
+import "./constants-5bd557fe.js";
+import "./TileContainer-456a6c78.js";
+import "./FeatureCommandQueue-d3930db2.js";
+import "./BufferObject-0c76346f.js";
+import "./VertexArrayObject-4a28edd2.js";
+import "./vec3f32-304a6a9c.js";
+import "./AttributeStore-47a878e7.js";
+import "./labelUtils-31fc2428.js";
+import "./TimeOnly-e45c6726.js";
+import "./timeSupport-97c324f3.js";
+import "./featureConversionUtils-90914512.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./json-5febf88a.js";
+import "./normalizeUtilsSync-ceab37a3.js";
+import "./vec4f32-b2628ced.js";
+import "./ProgramTemplate-e7665148.js";
+import "./StyleDefinition-f4862d5a.js";
+import "./config-61215215.js";
+import "./programUtils-af41c65f.js";
+import "./NestedMap-83f8e815.js";
+import "./OrderIndependentTransparency-3eadfe42.js";
+import "./basicInterfaces-fa4f5fa7.js";
+import "./testSVGPremultipliedAlpha-10b2acab.js";
+import "./floatRGBA-d8908329.js";
+import "./doublePrecisionUtils-46e21550.js";
+class h {
+  constructor(t) {
+    if (this._ownsRctx = !1, t)
+      this._ownsRctx = !1, this._rctx = t;
+    else {
+      if (h._instance)
+        return h._instanceRefCount++, h._instance;
+      h._instanceRefCount = 1, h._instance = this, this._ownsRctx = !0;
+      const i = document.createElement("canvas"), a = G(i);
+      a.getExtension("OES_texture_float"), this._rctx = new lt(a, {});
+    }
+    const s = { applyProjection: !0, bilinear: !1, bicubic: !1 }, r = pt("raster/reproject", "raster/reproject", /* @__PURE__ */ new Map([["a_position", 0]]), s);
+    this._program = this._rctx.programCache.acquire(r.shaders.vertexShader, r.shaders.fragmentShader, r.attributes), this._rctx.useProgram(this._program), this._program.setUniform1f("u_opacity", 1), this._program.setUniform1i("u_image", 0), this._program.setUniform1i("u_flipY", 0), this._program.setUniform1i("u_transformGrid", 1), this._quad = new nt(this._rctx, [0, 0, 1, 0, 0, 1, 1, 1]);
+  }
+  reprojectTexture(t, s, r = !1) {
+    const i = T(t.extent, s), a = new k({ x: (t.extent.xmax - t.extent.xmin) / t.texture.descriptor.width, y: (t.extent.ymax - t.extent.ymin) / t.texture.descriptor.height, spatialReference: t.extent.spatialReference }), { x: o, y: p } = rt(a, s, t.extent);
+    let n = (o + p) / 2;
+    const l = Math.round((i.xmax - i.xmin) / n), u = Math.round((i.ymax - i.ymin) / n);
+    n = (i.width / l + i.height / u) / 2;
+    const I = new k({ x: n, y: n, spatialReference: i.spatialReference }), g = ot({ projectedExtent: i, srcBufferExtent: t.extent, pixelSize: I, hasWrapAround: !0, spacing: [16, 16] }), w = dt(this._rctx, g), y = new q(l, u);
+    y.wrapMode = E.CLAMP_TO_EDGE;
+    const m = new ct(this._rctx, y);
+    this._rctx.bindFramebuffer(m), this._rctx.setViewport(0, 0, l, u), this._rctx.useProgram(this._program), this._rctx.bindTexture(t.texture, 0), this._rctx.bindTexture(w, 1), this._quad.bind();
+    const { width: x = 0, height: f = 0 } = t.texture.descriptor;
+    if (this._program.setUniform2f("u_srcImageSize", x, f), this._program.setUniform2fv("u_transformSpacing", g.spacing), this._program.setUniform2fv("u_transformGridSize", g.size), this._program.setUniform2f("u_targetImageSize", l, u), this._quad.draw(), this._quad.unbind(), this._rctx.useProgram(null), this._rctx.bindFramebuffer(null), w.dispose(), r) {
+      const { width: c, height: V } = m, _ = new ImageData(c ?? 0, V ?? 0);
+      m.readPixels(0, 0, c ?? 0, V ?? 0, ht.RGBA, mt.UNSIGNED_BYTE, _.data);
+      const B = m.detachColorTexture(L.COLOR_ATTACHMENT0);
+      return m.dispose(), { texture: B, extent: i, imageData: _ };
+    }
+    const b = m.detachColorTexture(L.COLOR_ATTACHMENT0);
+    return m.dispose(), { texture: b, extent: i };
+  }
+  reprojectBitmapData(t, s) {
+    const r = Z(t.bitmapData) ? tt(t.bitmapData) : t.bitmapData, i = new q();
+    i.wrapMode = E.CLAMP_TO_EDGE, i.width = t.bitmapData.width, i.height = t.bitmapData.height;
+    const a = new ut(this._rctx, i, r), o = this.reprojectTexture({ texture: a, extent: t.extent }, s, !0);
+    o.texture.dispose();
+    const p = document.createElement("canvas"), n = o.imageData;
+    return p.width = n.width, p.height = n.height, p.getContext("2d").putImageData(n, 0, 0), { bitmapData: p, extent: o.extent };
+  }
+  async loadAndReprojectBitmapData(t, s, r) {
+    const i = (await z(t, { responseType: "image" })).data, a = document.createElement("canvas");
+    a.width = i.width, a.height = i.height;
+    const o = a.getContext("2d");
+    o.drawImage(i, 0, 0);
+    const p = o.getImageData(0, 0, a.width, a.height);
+    if (s.spatialReference.equals(r))
+      return { bitmapData: p, extent: s };
+    const n = this.reprojectBitmapData({ bitmapData: p, extent: s }, r);
+    return { bitmapData: n.bitmapData, extent: n.extent };
+  }
+  destroy() {
+    this._ownsRctx ? (h._instanceRefCount--, h._instanceRefCount === 0 && (this._quad.dispose(), this._program.dispose(), this._rctx.dispose(), h._instance = null)) : (this._quad.dispose(), this._program.dispose());
+  }
+}
+h._instanceRefCount = 0;
+class j {
+  constructor() {
+    this.allSublayers = /* @__PURE__ */ new Map(), this.allPoints = [], this.allPolylines = [], this.allPolygons = [], this.allMapImages = [];
+  }
+}
+let d = class extends at(st) {
+  constructor() {
+    super(...arguments), this._bitmapIndex = /* @__PURE__ */ new Map(), this._mapImageContainer = new it(), this._kmlVisualData = new j(), this._fetchController = null, this.allVisiblePoints = new D(), this.allVisiblePolylines = new D(), this.allVisiblePolygons = new D(), this.allVisibleMapImages = new F();
+  }
+  async hitTest(e, t) {
+    var r, i, a;
+    const s = this.layer;
+    return [(r = this._pointsView) == null ? void 0 : r.hitTest(e), (i = this._polylinesView) == null ? void 0 : i.hitTest(e), (a = this._polygonsView) == null ? void 0 : a.hitTest(e)].flat().filter(Boolean).map((o) => (o.layer = s, o.sourceLayer = s, { type: "graphic", graphic: o, layer: s, mapPoint: e }));
+  }
+  update(e) {
+    this._polygonsView && this._polygonsView.processUpdate(e), this._polylinesView && this._polylinesView.processUpdate(e), this._pointsView && this._pointsView.processUpdate(e);
+  }
+  attach() {
+    this._fetchController = new AbortController(), this.container.addChild(this._mapImageContainer), this._polygonsView = new R({ view: this.view, graphics: this.allVisiblePolygons, requestUpdateCallback: () => this.requestUpdate(), container: new M(this.view.featuresTilingScheme) }), this.container.addChild(this._polygonsView.container), this._polylinesView = new R({ view: this.view, graphics: this.allVisiblePolylines, requestUpdateCallback: () => this.requestUpdate(), container: new M(this.view.featuresTilingScheme) }), this.container.addChild(this._polylinesView.container), this._pointsView = new R({ view: this.view, graphics: this.allVisiblePoints, requestUpdateCallback: () => this.requestUpdate(), container: new M(this.view.featuresTilingScheme) }), this.container.addChild(this._pointsView.container), this.addAttachHandles([this.allVisibleMapImages.on("change", (e) => {
+      e.added.forEach((t) => this._addMapImage(t)), e.removed.forEach((t) => this._removeMapImage(t));
+    }), O(() => this.layer.visibleSublayers, (e) => {
+      for (const [t, s] of this._kmlVisualData.allSublayers)
+        s.visibility = 0;
+      for (const t of e) {
+        const s = this._kmlVisualData.allSublayers.get(t.id);
+        s && (s.visibility = 1);
+      }
+      this._refreshCollections();
+    })]), this._updatingHandles.addPromise(this._fetchService(this._fetchController.signal)), this._imageReprojector = new h();
+  }
+  detach() {
+    this._fetchController = N(this._fetchController), this._mapImageContainer.removeAllChildren(), this.container.removeAllChildren(), this._bitmapIndex.clear(), this._polygonsView = C(this._polygonsView), this._polylinesView = C(this._polylinesView), this._pointsView = C(this._pointsView), this._imageReprojector = C(this._imageReprojector);
+  }
+  moveStart() {
+  }
+  viewChange() {
+    this._polygonsView.viewChange(), this._polylinesView.viewChange(), this._pointsView.viewChange();
+  }
+  moveEnd() {
+  }
+  isUpdating() {
+    return this._pointsView.updating || this._polygonsView.updating || this._polylinesView.updating;
+  }
+  _addMapImage(e) {
+    var t, s;
+    ((t = this.view.spatialReference) != null && t.isWGS84 || (s = this.view.spatialReference) != null && s.isWebMercator) && this._imageReprojector.loadAndReprojectBitmapData(e.href, U.fromJSON(e.extent), this.view.spatialReference).then((r) => {
+      const i = new et(r.bitmapData);
+      i.x = r.extent.xmin, i.y = r.extent.ymax, i.resolution = r.extent.width / r.bitmapData.width, i.rotation = e.rotation, this._mapImageContainer.addChild(i), this._bitmapIndex.set(e, i);
+    });
+  }
+  async _getViewDependentUrl(e, t) {
+    const { viewFormat: s, viewBoundScale: r, httpQuery: i } = e;
+    if (s != null) {
+      if (t == null)
+        throw new Error("Loading this network link requires a view state.");
+      let a;
+      if (await W(), r != null && r !== 1) {
+        const c = new U(t.extent);
+        c.expand(r), a = c;
+      } else
+        a = t.extent;
+      a = T(a, $.WGS84);
+      const o = T(a, $.WebMercator), p = a.xmin, n = a.xmax, l = a.ymin, u = a.ymax, I = t.size[0] * t.pixelRatio, g = t.size[1] * t.pixelRatio, w = Math.max(o.width, o.height), y = { "[bboxWest]": p.toString(), "[bboxEast]": n.toString(), "[bboxSouth]": l.toString(), "[bboxNorth]": u.toString(), "[lookatLon]": a.center.x.toString(), "[lookatLat]": a.center.y.toString(), "[lookatRange]": w.toString(), "[lookatTilt]": "0", "[lookatHeading]": t.rotation.toString(), "[lookatTerrainLon]": a.center.x.toString(), "[lookatTerrainLat]": a.center.y.toString(), "[lookatTerrainAlt]": "0", "[cameraLon]": a.center.x.toString(), "[cameraLat]": a.center.y.toString(), "[cameraAlt]": w.toString(), "[horizFov]": "60", "[vertFov]": "60", "[horizPixels]": I.toString(), "[vertPixels]": g.toString(), "[terrainEnabled]": "0", "[clientVersion]": H, "[kmlVersion]": "2.2", "[clientName]": "ArcGIS API for JavaScript", "[language]": "en-US" }, m = (c) => {
+        for (const V in c) {
+          let _;
+          for (_ in y)
+            c[V] = c[V].replace(_, y[_]);
+        }
+      }, x = A(s);
+      m(x);
+      let f = {};
+      i != null && (f = A(i), m(f));
+      const b = K(e.href);
+      return b.query = { ...b.query, ...x, ...f }, `${b.path}?${J(x)}`;
+    }
+    return e.href;
+  }
+  async _fetchService(e) {
+    const t = new j();
+    await this._loadVisualData(this.layer.url, t, e), this._kmlVisualData = t, this._refreshCollections();
+  }
+  _refreshCollections() {
+    this.allVisiblePoints.removeAll(), this.allVisiblePolylines.removeAll(), this.allVisiblePolygons.removeAll(), this.allVisibleMapImages.removeAll(), this.allVisiblePoints.addMany(this._kmlVisualData.allPoints.filter((e) => this._isSublayerVisible(e.sublayerId)).map(({ item: e }) => e)), this.allVisiblePolylines.addMany(this._kmlVisualData.allPolylines.filter((e) => this._isSublayerVisible(e.sublayerId)).map(({ item: e }) => e)), this.allVisiblePolygons.addMany(this._kmlVisualData.allPolygons.filter((e) => this._isSublayerVisible(e.sublayerId)).map(({ item: e }) => e)), this.allVisibleMapImages.addMany(this._kmlVisualData.allMapImages.filter((e) => this._isSublayerVisible(e.sublayerId)).map(({ item: e }) => e));
+  }
+  _isSublayerVisible(e) {
+    const t = this._kmlVisualData.allSublayers.get(e);
+    return !!(t != null && t.visibility) && (t.parentFolderId === -1 || this._isSublayerVisible(t.parentFolderId));
+  }
+  _loadVisualData(e, t, s) {
+    return this._fetchParsedKML(e, s).then(async (r) => {
+      for (const i of r.sublayers) {
+        t.allSublayers.set(i.id, i);
+        const a = i.points ? await P(i.points) : [], o = i.polylines ? await P(i.polylines) : [], p = i.polygons ? await P(i.polygons) : [], n = i.mapImages || [];
+        if (t.allPoints.push(...a.map((l) => ({ item: l, sublayerId: i.id }))), t.allPolylines.push(...o.map((l) => ({ item: l, sublayerId: i.id }))), t.allPolygons.push(...p.map((l) => ({ item: l, sublayerId: i.id }))), t.allMapImages.push(...n.map((l) => ({ item: l, sublayerId: i.id }))), i.networkLink) {
+          const l = await this._getViewDependentUrl(i.networkLink, this.view.state);
+          await this._loadVisualData(l, t, s);
+        }
+      }
+    });
+  }
+  _fetchParsedKML(e, t) {
+    return Q(e, this.layer.spatialReference, this.layer.refreshInterval, t).then((s) => X(s.data));
+  }
+  _removeMapImage(e) {
+    const t = this._bitmapIndex.get(e);
+    t && (this._mapImageContainer.removeChild(t), this._bitmapIndex.delete(e));
+  }
+};
+v([S()], d.prototype, "_pointsView", void 0), v([S()], d.prototype, "_polylinesView", void 0), v([S()], d.prototype, "_polygonsView", void 0), v([S()], d.prototype, "updating", void 0), d = v([Y("esri.views.2d.layers.KMLLayerView2D")], d);
+const Oe = d;
+export {
+  Oe as default
+};

package/dist/KnowledgeGraphLayerView2D-372e6484.js

@@ -0,0 +1,43 @@
+import { V as a, E as n, e as i, y as s, F as o, c as l } from "./index-4ead5b97.js";
+import { m as h, u as d } from "./LayerView-3582efbb.js";
+import "vue";
+import "./scaleUtils-0293f229.js";
+import "./Container-d699fcb8.js";
+import "./parser-bab9c2ce.js";
+import "./highlightReasons-79f118f3.js";
+import "./definitions-a00a3a6c.js";
+import "./enums-2c166c09.js";
+import "./Texture-cb75240c.js";
+let t = class extends h(d) {
+  constructor(e) {
+    super(e), this.layerViews = new a();
+  }
+  set layerViews(e) {
+    this._set("layerViews", n(e, this._get("layerViews")));
+  }
+  get updatingProgress() {
+    return this.layerViews.length === 0 ? 1 : this.layerViews.reduce((e, r) => e + r.updatingProgress, 0) / this.layerViews.length;
+  }
+  attach() {
+    this._updateStageChildren(), this.addAttachHandles(this.layerViews.on("after-changes", () => this._updateStageChildren()));
+  }
+  detach() {
+    this.container.removeAllChildren();
+  }
+  update(e) {
+  }
+  moveStart() {
+  }
+  viewChange() {
+  }
+  moveEnd() {
+  }
+  _updateStageChildren() {
+    this.container.removeAllChildren(), this.layerViews.forEach((e, r) => this.container.addChildAt(e.container, r));
+  }
+};
+i([s({ cast: o })], t.prototype, "layerViews", null), i([s({ readOnly: !0 })], t.prototype, "updatingProgress", null), t = i([l("esri.views.2d.layers.KnowledgeGraphLayerView2D")], t);
+const f = t;
+export {
+  f as default
+};

package/dist/LRUCache-7a6c25d0.js

@@ -0,0 +1,32 @@
+import { h as r } from "./MemCache-cfd09d4d.js";
+class o {
+  constructor(t, e) {
+    this._storage = new r(), this.id = "", this.name = "", this.size = 0, this._storage.maxSize = t, this._storage.register(this), e && this._storage.registerRemoveFunc("", e);
+  }
+  destroy() {
+    this._storage.deregister(this), this._storage.destroy();
+  }
+  put(t, e, s = 1) {
+    this._storage.put(this, t, e, s, 1);
+  }
+  pop(t) {
+    return this._storage.pop(this, t);
+  }
+  get(t) {
+    return this._storage.get(this, t);
+  }
+  clear() {
+    this._storage.clearAll();
+  }
+  get maxSize() {
+    return this._storage.maxSize;
+  }
+  set maxSize(t) {
+    this._storage.maxSize = t;
+  }
+  resetHitRate() {
+  }
+}
+export {
+  o as e
+};