@agrotools1/at-components 0.2.3 → 0.2.4

package/dist/VertexColor.glsl-01eb58bb.js

@@ -0,0 +1,2683 @@
+import { bs as ir, gZ as nr, Q as ft, bH as Jr, fj as Pt, aS as es, W as bt, s as or, S as cr, iw as ue, cK as ts, l1 as rs, l2 as ss, l3 as as, fg as H, bd as is, bf as ns, b as It, b9 as b, e as L, y as D, c as os, cv as nt, gQ as ge, ez as cs, bt as ls, L as us, bp as ee, bo as ae, l4 as ds, ej as ye, bg as qe, j4 as pt, gf as $t, hs, bn as lr, h0 as ms, dc as fs, e3 as Ft, iN as ps, fp as Ue, j6 as Ve, bJ as Dt, l5 as vs, gU as _s, gX as gs, l as Ts, bm as Te, kr as Es, gc as Ss, g7 as Se, fr as be, gn as As, ge as xs, gv as Bt, l6 as Os, l7 as Ht, gd as Rs, l8 as ur, l9 as dr } from "./index-f28919b2.js";
+import { E as bs, c as le, G as Re, L as Ce, D as vt, O as we, I as Z } from "./enums-2c166c09.js";
+import { c as Is, m as ze, a as $s, e as Ls } from "./Texture-c1f5f21b.js";
+import { s as _t } from "./vec42-1a7bd7a6.js";
+import { n as Lt, r as hr } from "./vec4f64-043e974c.js";
+import { o as l, n as Me } from "./OrderIndependentTransparency-3eadfe42.js";
+import { a as R } from "./BindType-5e76c8e1.js";
+import { s as U } from "./Util-26f81cc4.js";
+import { e as m } from "./VertexAttribute-faad30bf.js";
+import { e as Ne } from "./mat3f64-03233387.js";
+import { a as gt, t as ys, i as Cs, u as Ge, N as he } from "./basicInterfaces-fa4f5fa7.js";
+import { e as Ae, o as rt, r as ws } from "./mat4f64-cce69db4.js";
+import { t as Ms, l as Ns } from "./Indices-2f9cf62d.js";
+import { e as xe, d as Ps, o as Fs } from "./triangle-95e355d3.js";
+import { o as Ds, r as Bs } from "./doublePrecisionUtils-46e21550.js";
+import "./lengthUtils-8796ccf3.js";
+import { t as Hs } from "./requestImageUtils-f8f50ad7.js";
+import { w as mr, Z as de } from "./sphere-84d1e36b.js";
+import { O as Us, L as Vs } from "./orientedBoundingBox-46d44acf.js";
+import { x as fr, c as Ut, y as zs, u as Gs, q as Ws, i as Vt } from "./BufferView-2cfe8c7d.js";
+function gn(t, e = !1) {
+  return t <= ir ? e ? new Array(t).fill(0) : new Array(t) : new Float32Array(t);
+}
+let yt = class {
+  constructor() {
+    this.id = nr();
+  }
+}, ks = class {
+  constructor(e) {
+    this.channel = e, this.id = nr();
+  }
+};
+function js(t, e) {
+  return t == null && (t = []), t.push(e), t;
+}
+function qs(t, e) {
+  if (t == null)
+    return null;
+  const r = t.filter((s) => s !== e);
+  return r.length === 0 ? null : r;
+}
+let Sn = class {
+  constructor(e, r) {
+    this._module = e, this._loadModule = r;
+  }
+  get() {
+    return this._module;
+  }
+  async reload() {
+    return this._module = await this._loadModule(), this._module;
+  }
+}, xn = class {
+  constructor(e, r, s) {
+    this.release = s, this.initializeConfiguration(e, r), this._configuration = r.snapshot(), this._program = this.initializeProgram(e), this._pipeline = this.initializePipeline(e);
+  }
+  destroy() {
+    this._program = ft(this._program), this._pipeline = this._configuration = null;
+  }
+  reload(e) {
+    ft(this._program), this._program = this.initializeProgram(e), this._pipeline = this.initializePipeline(e);
+  }
+  get program() {
+    return this._program;
+  }
+  get compiled() {
+    return this.program.compiled;
+  }
+  get key() {
+    return this._configuration.key;
+  }
+  get configuration() {
+    return this._configuration;
+  }
+  ensureAttributeLocations(e) {
+    this.program.assertCompatibleVertexAttributeLocations(e);
+  }
+  get primitiveType() {
+    return bs.TRIANGLES;
+  }
+  getPipeline(e, r, s) {
+    return this._pipeline;
+  }
+  initializeConfiguration(e, r) {
+  }
+}, Rn = class {
+  constructor(e, r, s) {
+    this._context = e, this._locations = s, this._textures = /* @__PURE__ */ new Map(), this._freeTextureUnits = new Jr({ deallocator: null }), this._glProgram = e.programCache.acquire(r.generate("vertex"), r.generate("fragment"), s), this._glProgram.stop = () => {
+      throw new Error("Wrapped _glProgram used directly");
+    }, this.bindPass = r.generateBindPass(this), this.bindDraw = r.generateBindDraw(this), this._fragmentUniforms = Is() ? r.fragmentUniforms : null;
+  }
+  dispose() {
+    this._glProgram.dispose();
+  }
+  get glName() {
+    return this._glProgram.glName;
+  }
+  get hasTransformFeedbackVaryings() {
+    return this._glProgram.hasTransformFeedbackVaryings;
+  }
+  get compiled() {
+    return this._glProgram.compiled;
+  }
+  setUniform1b(e, r) {
+    this._glProgram.setUniform1i(e, r ? 1 : 0);
+  }
+  setUniform1i(e, r) {
+    this._glProgram.setUniform1i(e, r);
+  }
+  setUniform1f(e, r) {
+    this._glProgram.setUniform1f(e, r);
+  }
+  setUniform2fv(e, r) {
+    this._glProgram.setUniform2fv(e, r);
+  }
+  setUniform3fv(e, r) {
+    this._glProgram.setUniform3fv(e, r);
+  }
+  setUniform4fv(e, r) {
+    this._glProgram.setUniform4fv(e, r);
+  }
+  setUniformMatrix3fv(e, r) {
+    this._glProgram.setUniformMatrix3fv(e, r);
+  }
+  setUniformMatrix4fv(e, r) {
+    this._glProgram.setUniformMatrix4fv(e, r);
+  }
+  setUniform1fv(e, r) {
+    this._glProgram.setUniform1fv(e, r);
+  }
+  setUniform1iv(e, r) {
+    this._glProgram.setUniform1iv(e, r);
+  }
+  setUniform2iv(e, r) {
+    this._glProgram.setUniform3iv(e, r);
+  }
+  setUniform3iv(e, r) {
+    this._glProgram.setUniform3iv(e, r);
+  }
+  setUniform4iv(e, r) {
+    this._glProgram.setUniform4iv(e, r);
+  }
+  assertCompatibleVertexAttributeLocations(e) {
+    e.locations !== this._locations && console.error("VertexAttributeLocations are incompatible");
+  }
+  stop() {
+    this._textures.clear(), this._freeTextureUnits.clear();
+  }
+  bindTexture(e, r) {
+    if ((r == null ? void 0 : r.glName) == null) {
+      const a = this._textures.get(e);
+      return a && (this._context.bindTexture(null, a.unit), this._freeTextureUnit(a), this._textures.delete(e)), null;
+    }
+    let s = this._textures.get(e);
+    return s == null ? (s = this._allocTextureUnit(r), this._textures.set(e, s)) : s.texture = r, this._context.useProgram(this), this.setUniform1i(e, s.unit), this._context.bindTexture(r, s.unit), s.unit;
+  }
+  rebindTextures() {
+    var e;
+    this._context.useProgram(this), this._textures.forEach((r, s) => {
+      this._context.bindTexture(r.texture, r.unit), this.setUniform1i(s, r.unit);
+    }), (e = this._fragmentUniforms) == null || e.forEach((r) => {
+      r.type !== "sampler2D" && r.type !== "samplerCube" || this._textures.has(r.name) || console.error(`Texture sampler ${r.name} has no bound texture`);
+    });
+  }
+  _allocTextureUnit(e) {
+    return { texture: e, unit: this._freeTextureUnits.length === 0 ? this._textures.size : this._freeTextureUnits.pop() };
+  }
+  _freeTextureUnit(e) {
+    this._freeTextureUnits.push(e.unit);
+  }
+};
+function pr(t) {
+  t.code.add(l`const float MAX_RGBA_FLOAT =
+255.0 / 256.0 +
+255.0 / 256.0 / 256.0 +
+255.0 / 256.0 / 256.0 / 256.0 +
+255.0 / 256.0 / 256.0 / 256.0 / 256.0;
+const vec4 FIXED_POINT_FACTORS = vec4(1.0, 256.0, 256.0 * 256.0, 256.0 * 256.0 * 256.0);
+vec4 float2rgba(const float value) {
+float valueInValidDomain = clamp(value, 0.0, MAX_RGBA_FLOAT);
+vec4 fixedPointU8 = floor(fract(valueInValidDomain * FIXED_POINT_FACTORS) * 256.0);
+const float toU8AsFloat = 1.0 / 255.0;
+return fixedPointU8 * toU8AsFloat;
+}
+const vec4 RGBA_2_FLOAT_FACTORS = vec4(
+255.0 / (256.0),
+255.0 / (256.0 * 256.0),
+255.0 / (256.0 * 256.0 * 256.0),
+255.0 / (256.0 * 256.0 * 256.0 * 256.0)
+);
+float rgba2float(vec4 rgba) {
+return dot(rgba, RGBA_2_FLOAT_FACTORS);
+}`);
+}
+function Xs(t) {
+  t.include(pr), t.code.add(l`float linearDepthFromFloat(float depth, vec2 nearFar) {
+return -(depth * (nearFar[1] - nearFar[0]) + nearFar[0]);
+}
+float linearDepthFromRGBA(vec4 depth, vec2 nearFar) {
+return linearDepthFromFloat(rgba2float(depth), nearFar);
+}
+float linearDepthFromTexture(sampler2D depthTexture, vec2 uv, vec2 nearFar) {
+ivec2 iuv = ivec2(uv * vec2(textureSize(depthTexture, 0)));
+return linearDepthFromRGBA(texelFetch(depthTexture, iuv, 0), nearFar);
+}`);
+}
+function In(t) {
+  t.code.add(l`float linearizeDepth(float depth, vec2 nearFar) {
+float depthNdc = depth * 2.0 - 1.0;
+return (2.0 * nearFar[0] * nearFar[1]) / (depthNdc * (nearFar[1] - nearFar[0]) - (nearFar[1] + nearFar[0]));
+}
+float linearDepthFromTexture(sampler2D depthTexture, vec2 uv, vec2 nearFar) {
+ivec2 iuv = ivec2(uv * vec2(textureSize(depthTexture, 0)));
+float depth = texelFetch(depthTexture, iuv, 0).r;
+return linearizeDepth(depth, nearFar);
+}`);
+}
+let j = class {
+  constructor(e, r, s, a, i = null) {
+    if (this.name = e, this.type = r, this.arraySize = i, this.bind = { [R.Pass]: null, [R.Draw]: null }, a)
+      switch (s) {
+        case R.Pass:
+          this.bind[R.Pass] = a;
+          break;
+        case R.Draw:
+          this.bind[R.Draw] = a;
+      }
+  }
+  equals(e) {
+    return this.type === e.type && this.name === e.name && this.arraySize === e.arraySize;
+  }
+}, Ct = class extends j {
+  constructor(e, r) {
+    super(e, "vec2", R.Pass, (s, a, i) => s.setUniform2fv(e, r(a, i)));
+  }
+}, vr = class extends j {
+  constructor(e, r) {
+    super(e, "vec4", R.Pass, (s, a, i) => s.setUniform4fv(e, r(a, i)));
+  }
+};
+function Cn(t) {
+  t.fragment.uniforms.add(new vr("projInfo", (e, r) => Ys(r.camera))), t.fragment.uniforms.add(new Ct("zScale", (e, r) => Ks(r.camera))), t.fragment.code.add(l`vec3 reconstructPosition(vec2 fragCoord, float depth) {
+return vec3((fragCoord * projInfo.xy + projInfo.zw) * (zScale.x * depth + zScale.y), depth);
+}`);
+}
+function Ys(t) {
+  const e = t.projectionMatrix;
+  return e[11] === 0 ? _t(zt, 2 / (t.fullWidth * e[0]), 2 / (t.fullHeight * e[5]), (1 + e[12]) / e[0], (1 + e[13]) / e[5]) : _t(zt, -2 / (t.fullWidth * e[0]), -2 / (t.fullHeight * e[5]), (1 - e[8]) / e[0], (1 - e[9]) / e[5]);
+}
+const zt = Lt();
+function Ks(t) {
+  return t.projectionMatrix[11] === 0 ? Pt(Gt, 0, 1) : Pt(Gt, 1, 0);
+}
+const Gt = es();
+let q = class extends j {
+  constructor(e, r) {
+    super(e, "vec3", R.Pass, (s, a, i) => s.setUniform3fv(e, r(a, i)));
+  }
+}, Qs = class extends j {
+  constructor(e, r) {
+    super(e, "float", R.Pass, (s, a, i) => s.setUniform1f(e, r(a, i)));
+  }
+}, We = class extends j {
+  constructor(e, r) {
+    super(e, "sampler2D", R.Pass, (s, a, i) => s.bindTexture(e, r(a, i)));
+  }
+}, $e = class extends j {
+  constructor(e, r) {
+    super(e, "mat4", R.Pass, (s, a, i) => s.setUniformMatrix4fv(e, r(a, i)));
+  }
+};
+const _r = () => or.getLogger("esri.views.3d.webgl-engine.core.shaderModules.shaderBuilder");
+let gr = class {
+  constructor() {
+    this._includedModules = /* @__PURE__ */ new Map();
+  }
+  include(e, r) {
+    if (this._includedModules.has(e)) {
+      const s = this._includedModules.get(e);
+      if (s !== r) {
+        _r().error("Shader module included multiple times with different configuration.");
+        const a = /* @__PURE__ */ new Set();
+        for (const i of Object.keys(s))
+          s[i] !== e[i] && a.add(i);
+        for (const i of Object.keys(e))
+          s[i] !== e[i] && a.add(i);
+        a.forEach((i) => console.error(`  ${i}: current ${s[i]} new ${e[i]}`));
+      }
+    } else
+      this._includedModules.set(e, r), e(this.builder, r);
+  }
+}, Dn = class extends gr {
+  constructor() {
+    super(...arguments), this.vertex = new Wt(), this.fragment = new Wt(), this.attributes = new ea(), this.varyings = new ta(), this.extensions = new Tt(), this.constants = new Tr(), this.outputs = new St();
+  }
+  get fragmentUniforms() {
+    return this.fragment.uniforms.entries;
+  }
+  get builder() {
+    return this;
+  }
+  generate(e) {
+    const r = this.extensions.generateSource(e), s = this.attributes.generateSource(e), a = this.varyings.generateSource(e), i = e === "vertex" ? this.vertex : this.fragment, n = i.uniforms.generateSource(), o = i.code.generateSource(), c = e === "vertex" ? sa : ra, d = this.constants.generateSource().concat(i.constants.generateSource()), u = this.outputs.generateSource(e);
+    return `#version 300 es
+${r.join(`
+`)}
+
+${c}
+
+${d.join(`
+`)}
+
+${n.join(`
+`)}
+
+${s.join(`
+`)}
+
+${a.join(`
+`)}
+
+${u.join(`
+`)}
+
+${o.join(`
+`)}`;
+  }
+  generateBindPass(e) {
+    const r = /* @__PURE__ */ new Map();
+    this.vertex.uniforms.entries.forEach((i) => {
+      const n = i.bind[R.Pass];
+      n && r.set(i.name, n);
+    }), this.fragment.uniforms.entries.forEach((i) => {
+      const n = i.bind[R.Pass];
+      n && r.set(i.name, n);
+    });
+    const s = Array.from(r.values()), a = s.length;
+    return (i, n) => {
+      for (let o = 0; o < a; ++o)
+        s[o](e, i, n);
+    };
+  }
+  generateBindDraw(e) {
+    const r = /* @__PURE__ */ new Map();
+    this.vertex.uniforms.entries.forEach((i) => {
+      const n = i.bind[R.Draw];
+      n && r.set(i.name, n);
+    }), this.fragment.uniforms.entries.forEach((i) => {
+      const n = i.bind[R.Draw];
+      n && r.set(i.name, n);
+    });
+    const s = Array.from(r.values()), a = s.length;
+    return (i, n, o) => {
+      for (let c = 0; c < a; ++c)
+        s[c](e, i, n, o);
+    };
+  }
+}, Zs = class {
+  constructor() {
+    this._entries = /* @__PURE__ */ new Map();
+  }
+  add(...e) {
+    for (const r of e)
+      this._add(r);
+  }
+  get(e) {
+    return this._entries.get(e);
+  }
+  _add(e) {
+    if (e != null) {
+      if (this._entries.has(e.name) && !this._entries.get(e.name).equals(e))
+        throw new bt(`Duplicate uniform name ${e.name} for different uniform type`);
+      this._entries.set(e.name, e);
+    } else
+      _r().error(`Trying to add null Uniform from ${new Error().stack}.`);
+  }
+  generateSource() {
+    return Array.from(this._entries.values()).map((e) => e.arraySize != null ? `uniform ${e.type} ${e.name}[${e.arraySize}];` : `uniform ${e.type} ${e.name};`);
+  }
+  get entries() {
+    return Array.from(this._entries.values());
+  }
+}, Js = class {
+  constructor() {
+    this._entries = new Array();
+  }
+  add(e) {
+    this._entries.push(e);
+  }
+  generateSource() {
+    return this._entries;
+  }
+}, Wt = class extends gr {
+  constructor() {
+    super(...arguments), this.uniforms = new Zs(), this.code = new Js(), this.constants = new Tr();
+  }
+  get builder() {
+    return this;
+  }
+}, ea = class {
+  constructor() {
+    this._entries = new Array();
+  }
+  add(e, r) {
+    this._entries.push([e, r]);
+  }
+  generateSource(e) {
+    return e === "fragment" ? [] : this._entries.map((r) => `in ${r[1]} ${r[0]};`);
+  }
+}, ta = class {
+  constructor() {
+    this._entries = /* @__PURE__ */ new Map();
+  }
+  add(e, r) {
+    this._entries.has(e) && U(this._entries.get(e) === r), this._entries.set(e, r);
+  }
+  generateSource(e) {
+    const r = new Array();
+    return this._entries.forEach((s, a) => r.push(e === "vertex" ? `out ${s} ${a};` : `in ${s} ${a};`)), r;
+  }
+}, Tt = class Et {
+  constructor() {
+    this._entries = /* @__PURE__ */ new Set();
+  }
+  add(e) {
+    this._entries.add(e);
+  }
+  generateSource(e) {
+    const r = e === "vertex" ? Et.ALLOWLIST_VERTEX : Et.ALLOWLIST_FRAGMENT;
+    return Array.from(this._entries).filter((s) => r.includes(s)).map((s) => `#extension ${s} : enable`);
+  }
+};
+Tt.ALLOWLIST_FRAGMENT = ["GL_EXT_shader_texture_lod", "GL_OES_standard_derivatives"], Tt.ALLOWLIST_VERTEX = [];
+let St = class At {
+  constructor() {
+    this._entries = /* @__PURE__ */ new Map();
+  }
+  add(e, r, s = 0) {
+    const a = this._entries.get(s);
+    a ? U(a.name === e && a.type === r, `Fragment shader output location ${s} occupied`) : this._entries.set(s, { name: e, type: r });
+  }
+  generateSource(e) {
+    if (e === "vertex")
+      return [];
+    this._entries.size === 0 && this._entries.set(0, { name: At.DEFAULT_NAME, type: At.DEFAULT_TYPE });
+    const r = new Array();
+    return this._entries.forEach((s, a) => r.push(`layout(location = ${a}) out ${s.type} ${s.name};`)), r;
+  }
+};
+St.DEFAULT_TYPE = "vec4", St.DEFAULT_NAME = "fragColor";
+let Tr = class B {
+  constructor() {
+    this._entries = /* @__PURE__ */ new Set();
+  }
+  add(e, r, s) {
+    let a = "ERROR_CONSTRUCTOR_STRING";
+    switch (r) {
+      case "float":
+        a = B._numberToFloatStr(s);
+        break;
+      case "int":
+        a = B._numberToIntStr(s);
+        break;
+      case "bool":
+        a = s.toString();
+        break;
+      case "vec2":
+        a = `vec2(${B._numberToFloatStr(s[0])},                            ${B._numberToFloatStr(s[1])})`;
+        break;
+      case "vec3":
+        a = `vec3(${B._numberToFloatStr(s[0])},                            ${B._numberToFloatStr(s[1])},                            ${B._numberToFloatStr(s[2])})`;
+        break;
+      case "vec4":
+        a = `vec4(${B._numberToFloatStr(s[0])},                            ${B._numberToFloatStr(s[1])},                            ${B._numberToFloatStr(s[2])},                            ${B._numberToFloatStr(s[3])})`;
+        break;
+      case "ivec2":
+        a = `ivec2(${B._numberToIntStr(s[0])},                             ${B._numberToIntStr(s[1])})`;
+        break;
+      case "ivec3":
+        a = `ivec3(${B._numberToIntStr(s[0])},                             ${B._numberToIntStr(s[1])},                             ${B._numberToIntStr(s[2])})`;
+        break;
+      case "ivec4":
+        a = `ivec4(${B._numberToIntStr(s[0])},                             ${B._numberToIntStr(s[1])},                             ${B._numberToIntStr(s[2])},                             ${B._numberToIntStr(s[3])})`;
+        break;
+      case "mat2":
+      case "mat3":
+      case "mat4":
+        a = `${r}(${Array.prototype.map.call(s, (i) => B._numberToFloatStr(i)).join(", ")})`;
+    }
+    return this._entries.add(`const ${r} ${e} = ${a};`), this;
+  }
+  static _numberToIntStr(e) {
+    return e.toFixed(0);
+  }
+  static _numberToFloatStr(e) {
+    return Number.isInteger(e) ? e.toFixed(1) : e.toString();
+  }
+  generateSource() {
+    return Array.from(this._entries);
+  }
+};
+const ra = `#ifdef GL_FRAGMENT_PRECISION_HIGH
+  precision highp float;
+  precision highp sampler2D;
+#else
+  precision mediump float;
+  precision mediump sampler2D;
+#endif`, sa = `precision highp float;
+precision highp sampler2D;`;
+var x;
+function Wn(t) {
+  return aa(t) || t === x.Depth || t === x.LinearDepth || t === x.Normal || t === x.ObjectAndLayerIdColor;
+}
+function aa(t) {
+  return t === x.Shadow || t === x.ShadowHighlight || t === x.ShadowExcludeHighlight;
+}
+function kn(t) {
+  return na(t) || t === x.Normal;
+}
+function Er(t) {
+  return t === x.Highlight || t === x.ObjectAndLayerIdColor;
+}
+function jn(t) {
+  return t === x.Color || Er(t);
+}
+function Sr(t) {
+  return t === x.Color || t === x.Alpha;
+}
+function qn(t) {
+  return Sr(t) || t === x.ObjectAndLayerIdColor;
+}
+function ia(t) {
+  return Sr(t) || Er(t);
+}
+function na(t) {
+  return ia(t) || t === x.LinearDepth;
+}
+(function(t) {
+  t[t.Color = 0] = "Color", t[t.LinearDepth = 1] = "LinearDepth", t[t.Depth = 2] = "Depth", t[t.Normal = 3] = "Normal", t[t.Shadow = 4] = "Shadow", t[t.ShadowHighlight = 5] = "ShadowHighlight", t[t.ShadowExcludeHighlight = 6] = "ShadowExcludeHighlight", t[t.Highlight = 7] = "Highlight", t[t.Alpha = 8] = "Alpha", t[t.ObjectAndLayerIdColor = 9] = "ObjectAndLayerIdColor", t[t.CompositeColor = 10] = "CompositeColor", t[t.COUNT = 11] = "COUNT";
+})(x || (x = {}));
+const oa = { required: [] }, Xn = { required: [x.LinearDepth] };
+x.CompositeColor;
+x.Highlight;
+const Yn = { required: [x.Depth, x.Normal] };
+let Ar = class extends cr {
+  consumes() {
+    return oa;
+  }
+  get usedMemory() {
+    return 0;
+  }
+  get isDecoration() {
+    return !1;
+  }
+  get running() {
+    return !1;
+  }
+  get materialReference() {
+    return null;
+  }
+  modify(e) {
+  }
+  get numGeometries() {
+    return 0;
+  }
+  get hasOccludees() {
+    return !1;
+  }
+  queryRenderOccludedState(e) {
+    return !1;
+  }
+}, Qn = class extends Ar {
+}, Jn = class extends Ar {
+  constructor() {
+    super(...arguments), this.drapedPriority = 0;
+  }
+};
+var kt;
+(function(t) {
+  t[t.INTEGRATED_MESH = 0] = "INTEGRATED_MESH", t[t.OPAQUE_TERRAIN = 1] = "OPAQUE_TERRAIN", t[t.OPAQUE_MATERIAL = 2] = "OPAQUE_MATERIAL", t[t.OPAQUE_NO_SSAO_DEPTH = 3] = "OPAQUE_NO_SSAO_DEPTH", t[t.TRANSPARENT_MATERIAL = 4] = "TRANSPARENT_MATERIAL", t[t.TRANSPARENT_NO_SSAO_DEPTH = 5] = "TRANSPARENT_NO_SSAO_DEPTH", t[t.TRANSPARENT_TERRAIN = 6] = "TRANSPARENT_TERRAIN", t[t.TRANSPARENT_DEPTH_WRITE_DISABLED_MATERIAL = 7] = "TRANSPARENT_DEPTH_WRITE_DISABLED_MATERIAL", t[t.OCCLUDED_TERRAIN = 8] = "OCCLUDED_TERRAIN", t[t.OCCLUDER_MATERIAL = 9] = "OCCLUDER_MATERIAL", t[t.TRANSPARENT_OCCLUDER_MATERIAL = 10] = "TRANSPARENT_OCCLUDER_MATERIAL", t[t.OCCLUSION_PIXELS = 11] = "OCCLUSION_PIXELS", t[t.ANTIALIASING = 12] = "ANTIALIASING", t[t.COMPOSITE = 13] = "COMPOSITE", t[t.BLIT = 14] = "BLIT", t[t.SSAO = 15] = "SSAO", t[t.HIGHLIGHT = 16] = "HIGHLIGHT", t[t.SHADOW_HIGHLIGHT = 17] = "SHADOW_HIGHLIGHT", t[t.ENVIRONMENT_OPAQUE = 18] = "ENVIRONMENT_OPAQUE", t[t.ENVIRONMENT_TRANSPARENT = 19] = "ENVIRONMENT_TRANSPARENT", t[t.LASERLINES = 20] = "LASERLINES", t[t.LASERLINES_CONTRAST_CONTROL = 21] = "LASERLINES_CONTRAST_CONTROL", t[t.HUD_MATERIAL = 22] = "HUD_MATERIAL", t[t.LABEL_MATERIAL = 23] = "LABEL_MATERIAL", t[t.LINE_CALLOUTS = 24] = "LINE_CALLOUTS", t[t.LINE_CALLOUTS_HUD_DEPTH = 25] = "LINE_CALLOUTS_HUD_DEPTH", t[t.DRAPED_MATERIAL = 26] = "DRAPED_MATERIAL", t[t.DRAPED_WATER = 27] = "DRAPED_WATER", t[t.VOXEL = 28] = "VOXEL", t[t.MAX_SLOTS = 29] = "MAX_SLOTS";
+})(kt || (kt = {}));
+function ca(t) {
+  return Math.abs(t * t * t);
+}
+function xr(t, e, r) {
+  const s = r.parameters;
+  return ct.scale = Math.min(s.divisor / (e - s.offset), 1), ct.factor = ca(t), ct;
+}
+function Or(t, e) {
+  return ue(t * Math.max(e.scale, e.minScaleFactor), t, e.factor);
+}
+function la(t, e, r) {
+  const s = xr(t, e, r);
+  return s.minScaleFactor = 0, Or(1, s);
+}
+function to(t, e, r, s) {
+  s.scale = la(t, e, r), s.factor = 0, s.minScaleFactor = r.minScaleFactor;
+}
+function ro(t, e, r = [0, 0]) {
+  const s = Math.min(Math.max(e.scale, e.minScaleFactor), 1);
+  return r[0] = t[0] * s, r[1] = t[1] * s, r;
+}
+function ua(t, e, r, s) {
+  return Or(t, xr(e, r, s));
+}
+const ct = { scale: 0, factor: 0, minScaleFactor: 0 }, Xe = ts();
+function so(t, e, r, s, a, i) {
+  if (t.visible)
+    if (t.boundingInfo) {
+      U(t.type === xe.Mesh);
+      const n = e.tolerance;
+      Rr(t.boundingInfo, r, s, n, a, i);
+    } else {
+      const n = t.attributes.get(m.POSITION), o = n.indices;
+      Ir(r, s, 0, o.length / 3, o, n, void 0, a, i);
+    }
+}
+const da = b();
+function Rr(t, e, r, s, a, i) {
+  if (t == null)
+    return;
+  const n = ma(e, r, da);
+  if (ss(Xe, t.bbMin), as(Xe, t.bbMax), a != null && a.applyToAabb(Xe), fa(Xe, e, n, s)) {
+    const { primitiveIndices: o, position: c } = t, d = o ? o.length : c.indices.length / 3;
+    if (d > ga) {
+      const u = t.getChildren();
+      if (u !== void 0) {
+        for (const h of u)
+          Rr(h, e, r, s, a, i);
+        return;
+      }
+    }
+    Ir(e, r, 0, d, c.indices, c, o, a, i);
+  }
+}
+const br = b();
+function Ir(t, e, r, s, a, i, n, o, c) {
+  if (n)
+    return ha(t, e, r, s, a, i, n, o, c);
+  const { data: d, stride: u } = i, h = t[0], v = t[1], O = t[2], S = e[0] - h, V = e[1] - v, G = e[2] - O;
+  for (let F = r, k = 3 * r; F < s; ++F) {
+    let y = u * a[k++], I = d[y++], C = d[y++], w = d[y];
+    y = u * a[k++];
+    let T = d[y++], E = d[y++], A = d[y];
+    y = u * a[k++];
+    let g = d[y++], f = d[y++], p = d[y];
+    o != null && ([I, C, w] = o.applyToVertex(I, C, w, F), [T, E, A] = o.applyToVertex(T, E, A, F), [g, f, p] = o.applyToVertex(g, f, p, F));
+    const _ = T - I, $ = E - C, N = A - w, P = g - I, W = f - C, ie = p - w, me = V * ie - W * G, Pe = G * P - ie * S, Fe = S * W - P * V, J = _ * me + $ * Pe + N * Fe;
+    if (Math.abs(J) <= Number.EPSILON)
+      continue;
+    const X = h - I, fe = v - C, pe = O - w, se = X * me + fe * Pe + pe * Fe;
+    if (J > 0) {
+      if (se < 0 || se > J)
+        continue;
+    } else if (se > 0 || se < J)
+      continue;
+    const ne = fe * N - $ * pe, De = pe * _ - N * X, Be = X * $ - _ * fe, ve = S * ne + V * De + G * Be;
+    if (J > 0) {
+      if (ve < 0 || se + ve > J)
+        continue;
+    } else if (ve > 0 || se + ve < J)
+      continue;
+    const _e = (P * ne + W * De + ie * Be) / J;
+    _e >= 0 && c(_e, $r(_, $, N, P, W, ie, br), F, !1);
+  }
+}
+function ha(t, e, r, s, a, i, n, o, c) {
+  const { data: d, stride: u } = i, h = t[0], v = t[1], O = t[2], S = e[0] - h, V = e[1] - v, G = e[2] - O;
+  for (let F = r; F < s; ++F) {
+    const k = n[F];
+    let y = 3 * k, I = u * a[y++], C = d[I++], w = d[I++], T = d[I];
+    I = u * a[y++];
+    let E = d[I++], A = d[I++], g = d[I];
+    I = u * a[y];
+    let f = d[I++], p = d[I++], _ = d[I];
+    o != null && ([C, w, T] = o.applyToVertex(C, w, T, F), [E, A, g] = o.applyToVertex(E, A, g, F), [f, p, _] = o.applyToVertex(f, p, _, F));
+    const $ = E - C, N = A - w, P = g - T, W = f - C, ie = p - w, me = _ - T, Pe = V * me - ie * G, Fe = G * W - me * S, J = S * ie - W * V, X = $ * Pe + N * Fe + P * J;
+    if (Math.abs(X) <= Number.EPSILON)
+      continue;
+    const fe = h - C, pe = v - w, se = O - T, ne = fe * Pe + pe * Fe + se * J;
+    if (X > 0) {
+      if (ne < 0 || ne > X)
+        continue;
+    } else if (ne > 0 || ne < X)
+      continue;
+    const De = pe * P - N * se, Be = se * $ - P * fe, ve = fe * N - $ * pe, _e = S * De + V * Be + G * ve;
+    if (X > 0) {
+      if (_e < 0 || ne + _e > X)
+        continue;
+    } else if (_e > 0 || ne + _e < X)
+      continue;
+    const Nt = (W * De + ie * Be + me * ve) / X;
+    Nt >= 0 && c(Nt, $r($, N, P, W, ie, me, br), k, !1);
+  }
+}
+const jt = b(), qt = b();
+function $r(t, e, r, s, a, i, n) {
+  return H(jt, t, e, r), H(qt, s, a, i), is(n, jt, qt), ns(n, n), n;
+}
+function ma(t, e, r) {
+  return H(r, 1 / (e[0] - t[0]), 1 / (e[1] - t[1]), 1 / (e[2] - t[2]));
+}
+function fa(t, e, r, s) {
+  return pa(t, e, r, s, 1 / 0);
+}
+function pa(t, e, r, s, a) {
+  const i = (t[0] - s - e[0]) * r[0], n = (t[3] + s - e[0]) * r[0];
+  let o = Math.min(i, n), c = Math.max(i, n);
+  const d = (t[1] - s - e[1]) * r[1], u = (t[4] + s - e[1]) * r[1];
+  if (c = Math.min(c, Math.max(d, u)), c < 0 || (o = Math.max(o, Math.min(d, u)), o > c))
+    return !1;
+  const h = (t[2] - s - e[2]) * r[2], v = (t[5] + s - e[2]) * r[2];
+  return c = Math.min(c, Math.max(h, v)), !(c < 0) && (o = Math.max(o, Math.min(h, v)), !(o > c) && o < a);
+}
+function ao(t, e, r, s, a) {
+  let i = (r.screenLength || 0) * t.pixelRatio;
+  a != null && (i = ua(i, s, e, a));
+  const n = i * Math.tan(0.5 * t.fovY) / (0.5 * t.fullHeight);
+  return It(n * e, r.minWorldLength || 0, r.maxWorldLength != null ? r.maxWorldLength : 1 / 0);
+}
+function Lr(t, e) {
+  const r = e ? Lr(e) : {};
+  for (const s in t) {
+    let a = t[s];
+    a != null && a.forEach && (a = _a(a)), a == null && s in r || (r[s] = a);
+  }
+  return r;
+}
+function va(t, e) {
+  let r = !1;
+  for (const s in e) {
+    const a = e[s];
+    a !== void 0 && (Array.isArray(a) ? t[s] === null ? (t[s] = a.slice(), r = !0) : rs(t[s], a) && (r = !0) : t[s] !== a && (r = !0, t[s] = a));
+  }
+  return r;
+}
+function _a(t) {
+  const e = [];
+  return t.forEach((r) => e.push(r)), e;
+}
+const io = { multiply: 1, ignore: 2, replace: 3, tint: 4 }, ga = 1e3;
+let Ta = class extends Me {
+  constructor() {
+    super(), this._key = "", this._keyDirty = !1, this._parameterBits = this._parameterBits ? this._parameterBits.map(() => 0) : [], this._parameterNames || (this._parameterNames = []);
+  }
+  get key() {
+    return this._keyDirty && (this._keyDirty = !1, this._key = String.fromCharCode.apply(String, this._parameterBits)), this._key;
+  }
+  snapshot() {
+    const e = this._parameterNames, r = { key: this.key };
+    for (const s of e)
+      r[s] = this[s];
+    return r;
+  }
+};
+function ke(t = {}) {
+  return (e, r) => {
+    if (e._parameterNames = e._parameterNames ?? [], e._parameterNames.push(r), t.constValue != null)
+      Object.defineProperty(e, r, { get: () => t.constValue });
+    else {
+      const s = e._parameterNames.length - 1, a = t.count || 2, i = Math.ceil(Math.log2(a)), n = e._parameterBits ?? [0];
+      let o = 0;
+      for (; n[o] + i > 16; )
+        o++, o >= n.length && n.push(0);
+      e._parameterBits = n;
+      const c = n[o], d = (1 << i) - 1 << c;
+      n[o] += i, Object.defineProperty(e, r, { get() {
+        return this[s];
+      }, set(u) {
+        if (this[s] !== u && (this[s] = u, this._keyDirty = !0, this._parameterBits[o] = this._parameterBits[o] & ~d | +u << c & d, typeof u != "number" && typeof u != "boolean"))
+          throw new Error("Configuration value for " + r + " must be boolean or number, got " + typeof u);
+      } });
+    }
+  };
+}
+const Ea = /* @__PURE__ */ new Map([[m.POSITION, 0], [m.NORMAL, 1], [m.NORMALCOMPRESSED, 1], [m.UV0, 2], [m.COLOR, 3], [m.COLORFEATUREATTRIBUTE, 3], [m.SIZE, 4], [m.TANGENT, 4], [m.CENTEROFFSETANDDISTANCE, 5], [m.SYMBOLCOLOR, 5], [m.FEATUREATTRIBUTE, 6], [m.INSTANCEFEATUREATTRIBUTE, 6], [m.INSTANCECOLOR, 7], [m.OBJECTANDLAYERIDCOLOR, 7], [m.INSTANCEOBJECTANDLAYERIDCOLOR, 7], [m.INSTANCEMODEL, 8], [m.INSTANCEMODELNORMAL, 12], [m.INSTANCEMODELORIGINHI, 11], [m.INSTANCEMODELORIGINLO, 15]]);
+function oo(t, e = !0) {
+  t.attributes.add(m.POSITION, "vec2"), e && t.varyings.add("uv", "vec2"), t.vertex.code.add(l`
+    void main(void) {
+      gl_Position = vec4(position, 0.0, 1.0);
+      ${e ? l`uv = position * 0.5 + vec2(0.5);` : ""}
+    }
+  `);
+}
+let M = class extends cr {
+  constructor() {
+    super(...arguments), this.SCENEVIEW_HITTEST_RETURN_INTERSECTOR = !1, this.DECONFLICTOR_SHOW_VISIBLE = !1, this.DECONFLICTOR_SHOW_INVISIBLE = !1, this.DECONFLICTOR_SHOW_GRID = !1, this.LABELS_SHOW_BORDER = !1, this.TEXT_SHOW_BASELINE = !1, this.TEXT_SHOW_BORDER = !1, this.OVERLAY_DRAW_DEBUG_TEXTURE = !1, this.OVERLAY_SHOW_CENTER = !1, this.SHOW_POI = !1, this.TESTS_DISABLE_OPTIMIZATIONS = !1, this.TESTS_DISABLE_FAST_UPDATES = !1, this.DRAW_MESH_GEOMETRY_NORMALS = !1, this.FEATURE_TILE_FETCH_SHOW_TILES = !1, this.FEATURE_TILE_TREE_SHOW_TILES = !1, this.TERRAIN_TILE_TREE_SHOW_TILES = !1, this.I3S_TREE_SHOW_TILES = !1, this.I3S_SHOW_MODIFICATIONS = !1, this.LOD_INSTANCE_RENDERER_DISABLE_UPDATES = !1, this.LOD_INSTANCE_RENDERER_COLORIZE_BY_LEVEL = !1, this.EDGES_SHOW_HIDDEN_TRANSPARENT_EDGES = !1, this.LINE_WIREFRAMES = !1;
+  }
+};
+L([D()], M.prototype, "SCENEVIEW_HITTEST_RETURN_INTERSECTOR", void 0), L([D()], M.prototype, "DECONFLICTOR_SHOW_VISIBLE", void 0), L([D()], M.prototype, "DECONFLICTOR_SHOW_INVISIBLE", void 0), L([D()], M.prototype, "DECONFLICTOR_SHOW_GRID", void 0), L([D()], M.prototype, "LABELS_SHOW_BORDER", void 0), L([D()], M.prototype, "TEXT_SHOW_BASELINE", void 0), L([D()], M.prototype, "TEXT_SHOW_BORDER", void 0), L([D()], M.prototype, "OVERLAY_DRAW_DEBUG_TEXTURE", void 0), L([D()], M.prototype, "OVERLAY_SHOW_CENTER", void 0), L([D()], M.prototype, "SHOW_POI", void 0), L([D()], M.prototype, "TESTS_DISABLE_OPTIMIZATIONS", void 0), L([D()], M.prototype, "TESTS_DISABLE_FAST_UPDATES", void 0), L([D()], M.prototype, "DRAW_MESH_GEOMETRY_NORMALS", void 0), L([D()], M.prototype, "FEATURE_TILE_FETCH_SHOW_TILES", void 0), L([D()], M.prototype, "FEATURE_TILE_TREE_SHOW_TILES", void 0), L([D()], M.prototype, "TERRAIN_TILE_TREE_SHOW_TILES", void 0), L([D()], M.prototype, "I3S_TREE_SHOW_TILES", void 0), L([D()], M.prototype, "I3S_SHOW_MODIFICATIONS", void 0), L([D()], M.prototype, "LOD_INSTANCE_RENDERER_DISABLE_UPDATES", void 0), L([D()], M.prototype, "LOD_INSTANCE_RENDERER_COLORIZE_BY_LEVEL", void 0), L([D()], M.prototype, "EDGES_SHOW_HIDDEN_TRANSPARENT_EDGES", void 0), L([D()], M.prototype, "LINE_WIREFRAMES", void 0), M = L([os("esri.views.3d.support.DebugFlags")], M);
+const lo = new M();
+var Xt, Yt;
+(function(t) {
+  t[t.RED = 0] = "RED", t[t.RG = 1] = "RG", t[t.RGBA4 = 2] = "RGBA4", t[t.RGBA = 3] = "RGBA", t[t.RGBA_MIPMAP = 4] = "RGBA_MIPMAP", t[t.R16F = 5] = "R16F", t[t.RGBA16F = 6] = "RGBA16F";
+})(Xt || (Xt = {})), function(t) {
+  t[t.DEPTH_STENCIL_TEXTURE = 0] = "DEPTH_STENCIL_TEXTURE", t[t.DEPTH16_BUFFER = 1] = "DEPTH16_BUFFER";
+}(Yt || (Yt = {}));
+function Sa(t, e) {
+  switch (e.normalType) {
+    case K.Compressed:
+      t.attributes.add(m.NORMALCOMPRESSED, "vec2"), t.vertex.code.add(l`vec3 decompressNormal(vec2 normal) {
+float z = 1.0 - abs(normal.x) - abs(normal.y);
+return vec3(normal + sign(normal) * min(z, 0.0), z);
+}
+vec3 normalModel() {
+return decompressNormal(normalCompressed);
+}`);
+      break;
+    case K.Attribute:
+      t.attributes.add(m.NORMAL, "vec3"), t.vertex.code.add(l`vec3 normalModel() {
+return normal;
+}`);
+      break;
+    case K.ScreenDerivative:
+      t.fragment.code.add(l`vec3 screenDerivativeNormal(vec3 positionView) {
+return normalize(cross(dFdx(positionView), dFdy(positionView)));
+}`);
+      break;
+    default:
+      nt(e.normalType);
+    case K.COUNT:
+    case K.Ground:
+  }
+}
+var K;
+(function(t) {
+  t[t.Attribute = 0] = "Attribute", t[t.Compressed = 1] = "Compressed", t[t.Ground = 2] = "Ground", t[t.ScreenDerivative = 3] = "ScreenDerivative", t[t.COUNT = 4] = "COUNT";
+})(K || (K = {}));
+function Aa(t) {
+  t.attributes.add(m.POSITION, "vec3"), t.vertex.code.add(l`vec3 positionModel() { return position; }`);
+}
+function yr({ code: t }, e) {
+  e.doublePrecisionRequiresObfuscation ? t.add(l`vec3 dpPlusFrc(vec3 a, vec3 b) {
+return mix(a, a + b, vec3(notEqual(b, vec3(0))));
+}
+vec3 dpMinusFrc(vec3 a, vec3 b) {
+return mix(vec3(0), a - b, vec3(notEqual(a, b)));
+}
+vec3 dpAdd(vec3 hiA, vec3 loA, vec3 hiB, vec3 loB) {
+vec3 t1 = dpPlusFrc(hiA, hiB);
+vec3 e = dpMinusFrc(t1, hiA);
+vec3 t2 = dpMinusFrc(hiB, e) + dpMinusFrc(hiA, dpMinusFrc(t1, e)) + loA + loB;
+return t1 + t2;
+}`) : t.add(l`vec3 dpAdd(vec3 hiA, vec3 loA, vec3 hiB, vec3 loB) {
+vec3 t1 = hiA + hiB;
+vec3 e = t1 - hiA;
+vec3 t2 = ((hiB - e) + (hiA - (t1 - e))) + loA + loB;
+return t1 + t2;
+}`);
+}
+let te = class extends j {
+  constructor(e, r) {
+    super(e, "vec3", R.Draw, (s, a, i, n) => s.setUniform3fv(e, r(a, i, n)));
+  }
+}, Cr = class extends j {
+  constructor(e, r) {
+    super(e, "mat3", R.Draw, (s, a, i) => s.setUniformMatrix3fv(e, r(a, i)));
+  }
+}, ot = class extends j {
+  constructor(e, r) {
+    super(e, "mat3", R.Pass, (s, a, i) => s.setUniformMatrix3fv(e, r(a, i)));
+  }
+};
+function wr(t, e) {
+  t.include(Aa);
+  const r = t.vertex;
+  r.include(yr, e), t.varyings.add("vPositionWorldCameraRelative", "vec3"), t.varyings.add("vPosition_view", "vec3"), r.uniforms.add(new q("transformWorldFromViewTH", (s) => s.transformWorldFromViewTH), new q("transformWorldFromViewTL", (s) => s.transformWorldFromViewTL), new ot("transformViewFromCameraRelativeRS", (s) => s.transformViewFromCameraRelativeRS), new $e("transformProjFromView", (s) => s.transformProjFromView), new Cr("transformWorldFromModelRS", (s) => s.transformWorldFromModelRS), new te("transformWorldFromModelTH", (s) => s.transformWorldFromModelTH), new te("transformWorldFromModelTL", (s) => s.transformWorldFromModelTL)), r.code.add(l`vec3 positionWorldCameraRelative() {
+vec3 rotatedModelPosition = transformWorldFromModelRS * positionModel();
+vec3 transform_CameraRelativeFromModel = dpAdd(
+transformWorldFromModelTL,
+transformWorldFromModelTH,
+-transformWorldFromViewTL,
+-transformWorldFromViewTH
+);
+return transform_CameraRelativeFromModel + rotatedModelPosition;
+}`), r.code.add(l`
+    void forwardPosition(float fOffset) {
+      vPositionWorldCameraRelative = positionWorldCameraRelative();
+      if (fOffset != 0.0) {
+        vPositionWorldCameraRelative += fOffset * ${e.spherical ? l`normalize(transformWorldFromViewTL + vPositionWorldCameraRelative)` : l`vec3(0.0, 0.0, 1.0)`};
+      }
+
+      vPosition_view = transformViewFromCameraRelativeRS * vPositionWorldCameraRelative;
+      gl_Position = transformProjFromView * vec4(vPosition_view, 1.0);
+    }
+  `), t.fragment.uniforms.add(new q("transformWorldFromViewTL", (s) => s.transformWorldFromViewTL)), r.code.add(l`vec3 positionWorld() {
+return transformWorldFromViewTL + vPositionWorldCameraRelative;
+}`), t.fragment.code.add(l`vec3 positionWorld() {
+return transformWorldFromViewTL + vPositionWorldCameraRelative;
+}`);
+}
+class xa extends Me {
+  constructor() {
+    super(...arguments), this.transformWorldFromViewTH = b(), this.transformWorldFromViewTL = b(), this.transformViewFromCameraRelativeRS = Ne(), this.transformProjFromView = Ae();
+  }
+}
+let Oa = class extends Me {
+  constructor() {
+    super(...arguments), this.transformWorldFromModelRS = Ne(), this.transformWorldFromModelTH = b(), this.transformWorldFromModelTL = b();
+  }
+};
+function po(t, e) {
+  switch (e.normalType) {
+    case K.Attribute:
+    case K.Compressed:
+      t.include(Sa, e), t.varyings.add("vNormalWorld", "vec3"), t.varyings.add("vNormalView", "vec3"), t.vertex.uniforms.add(new Cr("transformNormalGlobalFromModel", (r) => r.transformNormalGlobalFromModel), new ot("transformNormalViewFromGlobal", (r) => r.transformNormalViewFromGlobal)), t.vertex.code.add(l`void forwardNormal() {
+vNormalWorld = transformNormalGlobalFromModel * normalModel();
+vNormalView = transformNormalViewFromGlobal * vNormalWorld;
+}`);
+      break;
+    case K.Ground:
+      t.include(wr, e), t.varyings.add("vNormalWorld", "vec3"), t.vertex.code.add(l`
+        void forwardNormal() {
+          vNormalWorld = ${e.spherical ? l`normalize(vPositionWorldCameraRelative);` : l`vec3(0.0, 0.0, 1.0);`}
+        }
+        `);
+      break;
+    case K.ScreenDerivative:
+      t.vertex.code.add(l`void forwardNormal() {}`);
+      break;
+    default:
+      nt(e.normalType);
+    case K.COUNT:
+  }
+}
+let vo = class extends xa {
+  constructor() {
+    super(...arguments), this.transformNormalViewFromGlobal = Ne();
+  }
+}, go = class extends Oa {
+  constructor() {
+    super(...arguments), this.transformNormalGlobalFromModel = Ne(), this.toMapSpace = Lt();
+  }
+};
+var Q;
+function Ra(t, e) {
+  switch (e.textureCoordinateType) {
+    case Q.Default:
+      return t.attributes.add(m.UV0, "vec2"), t.varyings.add("vuv0", "vec2"), void t.vertex.code.add(l`void forwardTextureCoordinates() {
+vuv0 = uv0;
+}`);
+    case Q.Compressed:
+      return t.attributes.add(m.UV0, "vec2"), t.varyings.add("vuv0", "vec2"), void t.vertex.code.add(l`vec2 getUV0() {
+return uv0 / 16384.0;
+}
+void forwardTextureCoordinates() {
+vuv0 = getUV0();
+}`);
+    case Q.Atlas:
+      return t.attributes.add(m.UV0, "vec2"), t.varyings.add("vuv0", "vec2"), t.attributes.add(m.UVREGION, "vec4"), t.varyings.add("vuvRegion", "vec4"), void t.vertex.code.add(l`void forwardTextureCoordinates() {
+vuv0 = uv0;
+vuvRegion = uvRegion;
+}`);
+    default:
+      nt(e.textureCoordinateType);
+    case Q.None:
+      return void t.vertex.code.add(l`void forwardTextureCoordinates() {}`);
+    case Q.COUNT:
+      return;
+  }
+}
+(function(t) {
+  t[t.None = 0] = "None", t[t.Default = 1] = "Default", t[t.Atlas = 2] = "Atlas", t[t.Compressed = 3] = "Compressed", t[t.COUNT = 4] = "COUNT";
+})(Q || (Q = {}));
+function ba(t) {
+  t.fragment.code.add(l`vec4 textureAtlasLookup(sampler2D tex, vec2 textureCoordinates, vec4 atlasRegion) {
+vec2 atlasScale = atlasRegion.zw - atlasRegion.xy;
+vec2 uvAtlas = fract(textureCoordinates) * atlasScale + atlasRegion.xy;
+float maxdUV = 0.125;
+vec2 dUVdx = clamp(dFdx(textureCoordinates), -maxdUV, maxdUV) * atlasScale;
+vec2 dUVdy = clamp(dFdy(textureCoordinates), -maxdUV, maxdUV) * atlasScale;
+return textureGrad(tex, uvAtlas, dUVdx, dUVdy);
+}`);
+}
+function Ia(t, e) {
+  switch (t.include(Ra, e), e.textureCoordinateType) {
+    case Q.Default:
+    case Q.Compressed:
+      return void t.fragment.code.add(l`vec4 textureLookup(sampler2D tex, vec2 uv) {
+return texture(tex, uv);
+}`);
+    case Q.Atlas:
+      return t.include(ba), void t.fragment.code.add(l`vec4 textureLookup(sampler2D tex, vec2 uv) {
+return textureAtlasLookup(tex, uv, vuvRegion);
+}`);
+    default:
+      nt(e.textureCoordinateType);
+    case Q.None:
+    case Q.COUNT:
+      return;
+  }
+}
+let lt = class extends j {
+  constructor(e, r) {
+    super(e, "sampler2D", R.Draw, (s, a, i) => s.bindTexture(e, r(a, i)));
+  }
+}, $a = class {
+  constructor(e) {
+    this._material = e.material, this._techniqueRepository = e.techniqueRep, this._output = e.output;
+  }
+  dispose() {
+    this._techniqueRepository.release(this._technique);
+  }
+  get technique() {
+    return this._technique;
+  }
+  get _stippleTextureRepository() {
+    return this._techniqueRepository.constructionContext.stippleTextureRepository;
+  }
+  get _markerTextureRepository() {
+    return this._techniqueRepository.constructionContext.markerTextureRepository;
+  }
+  ensureTechnique(e, r) {
+    return this._technique = this._techniqueRepository.releaseAndAcquire(e, this._material.getConfiguration(this._output, r), this._technique), this._technique;
+  }
+  ensureResources(e) {
+    return gt.LOADED;
+  }
+}, Ao = class extends $a {
+  constructor(e) {
+    super(e), this._numLoading = 0, this._disposed = !1, this._textureRepository = e.textureRepository, this._textureId = e.textureId, this._acquire(e.textureId, (r) => this._texture = r), this._acquire(e.normalTextureId, (r) => this._textureNormal = r), this._acquire(e.emissiveTextureId, (r) => this._textureEmissive = r), this._acquire(e.occlusionTextureId, (r) => this._textureOcclusion = r), this._acquire(e.metallicRoughnessTextureId, (r) => this._textureMetallicRoughness = r);
+  }
+  dispose() {
+    this._texture = ge(this._texture), this._textureNormal = ge(this._textureNormal), this._textureEmissive = ge(this._textureEmissive), this._textureOcclusion = ge(this._textureOcclusion), this._textureMetallicRoughness = ge(this._textureMetallicRoughness), this._disposed = !0;
+  }
+  ensureResources(e) {
+    return this._numLoading === 0 ? gt.LOADED : gt.LOADING;
+  }
+  get textureBindParameters() {
+    return new La(this._texture != null ? this._texture.glTexture : null, this._textureNormal != null ? this._textureNormal.glTexture : null, this._textureEmissive != null ? this._textureEmissive.glTexture : null, this._textureOcclusion != null ? this._textureOcclusion.glTexture : null, this._textureMetallicRoughness != null ? this._textureMetallicRoughness.glTexture : null);
+  }
+  updateTexture(e) {
+    this._texture != null && e === this._texture.id || (this._texture = ge(this._texture), this._textureId = e, this._acquire(this._textureId, (r) => this._texture = r));
+  }
+  _acquire(e, r) {
+    if (e == null)
+      return void r(null);
+    const s = this._textureRepository.acquire(e);
+    if (cs(s))
+      return ++this._numLoading, void s.then((a) => {
+        if (this._disposed)
+          return ge(a), void r(null);
+        r(a);
+      }).finally(() => --this._numLoading);
+    r(s);
+  }
+}, La = class extends Me {
+  constructor(e = null, r = null, s = null, a = null, i = null, n, o) {
+    super(), this.texture = e, this.textureNormal = r, this.textureEmissive = s, this.textureOcclusion = a, this.textureMetallicRoughness = i, this.scale = n, this.normalTextureTransformMatrix = o;
+  }
+};
+var Ie;
+(function(t) {
+  t[t.Disabled = 0] = "Disabled", t[t.Normal = 1] = "Normal", t[t.Schematic = 2] = "Schematic", t[t.Water = 3] = "Water", t[t.WaterOnIntegratedMesh = 4] = "WaterOnIntegratedMesh", t[t.Simplified = 5] = "Simplified", t[t.TerrainWithWater = 6] = "TerrainWithWater", t[t.COUNT = 7] = "COUNT";
+})(Ie || (Ie = {}));
+function Ro(t, e) {
+  const r = t.fragment, s = e.hasMetallicRoughnessTexture || e.hasEmissionTexture || e.hasOcclusionTexture;
+  if (e.pbrMode === Ie.Normal && s && t.include(Ia, e), e.pbrMode !== Ie.Schematic)
+    if (e.pbrMode !== Ie.Disabled) {
+      if (e.pbrMode === Ie.Normal) {
+        r.code.add(l`vec3 mrr;
+vec3 emission;
+float occlusion;`);
+        const a = e.pbrTextureBindType;
+        e.hasMetallicRoughnessTexture && (r.uniforms.add(a === R.Pass ? new We("texMetallicRoughness", (i) => i.textureMetallicRoughness) : new lt("texMetallicRoughness", (i) => i.textureMetallicRoughness)), r.code.add(l`void applyMetallnessAndRoughness(vec2 uv) {
+vec3 metallicRoughness = textureLookup(texMetallicRoughness, uv).rgb;
+mrr[0] *= metallicRoughness.b;
+mrr[1] *= metallicRoughness.g;
+}`)), e.hasEmissionTexture && (r.uniforms.add(a === R.Pass ? new We("texEmission", (i) => i.textureEmissive) : new lt("texEmission", (i) => i.textureEmissive)), r.code.add(l`void applyEmission(vec2 uv) {
+emission *= textureLookup(texEmission, uv).rgb;
+}`)), e.hasOcclusionTexture ? (r.uniforms.add(a === R.Pass ? new We("texOcclusion", (i) => i.textureOcclusion) : new lt("texOcclusion", (i) => i.textureOcclusion)), r.code.add(l`void applyOcclusion(vec2 uv) {
+occlusion *= textureLookup(texOcclusion, uv).r;
+}
+float getBakedOcclusion() {
+return occlusion;
+}`)) : r.code.add(l`float getBakedOcclusion() { return 1.0; }`), a === R.Pass ? r.uniforms.add(new q("emissionFactor", (i) => i.emissiveFactor), new q("mrrFactors", (i) => i.mrrFactors)) : r.uniforms.add(new te("emissionFactor", (i) => i.emissiveFactor), new te("mrrFactors", (i) => i.mrrFactors)), r.code.add(l`
+    void applyPBRFactors() {
+      mrr = mrrFactors;
+      emission = emissionFactor;
+      occlusion = 1.0;
+
+      ${e.hasMetallicRoughnessTexture ? l`applyMetallnessAndRoughness(${e.hasMetallicRoughnessTextureTransform ? l`metallicRoughnessUV` : "vuv0"});` : ""}
+
+      ${e.hasEmissionTexture ? l`applyEmission(${e.hasEmissiveTextureTransform ? l`emissiveUV` : "vuv0"});` : ""}
+
+      ${e.hasOcclusionTexture ? l`applyOcclusion(${e.hasOcclusionTextureTransform ? l`occlusionUV` : "vuv0"});` : ""}
+    }
+  `);
+      }
+    } else
+      r.code.add(l`float getBakedOcclusion() { return 1.0; }`);
+  else
+    r.code.add(l`vec3 mrr = vec3(0.0, 0.6, 0.2);
+vec3 emission = vec3(0.0);
+float occlusion = 1.0;
+void applyPBRFactors() {}
+float getBakedOcclusion() { return 1.0; }`);
+}
+function bo(t) {
+  t.vertex.code.add(l`const float PI = 3.141592653589793;`), t.fragment.code.add(l`const float PI = 3.141592653589793;
+const float LIGHT_NORMALIZATION = 1.0 / PI;
+const float INV_PI = 0.3183098861837907;
+const float HALF_PI = 1.570796326794897;`);
+}
+let Io = class extends j {
+  constructor(e, r) {
+    super(e, "bool", R.Pass, (s, a, i) => s.setUniform1b(e, r(a, i)));
+  }
+};
+function ya(t) {
+  if (t.length < ir)
+    return Array.from(t);
+  if (ls(t))
+    return Float64Array.from(t);
+  if (!("BYTES_PER_ELEMENT" in t))
+    return Array.from(t);
+  switch (t.BYTES_PER_ELEMENT) {
+    case 1:
+      return Uint8Array.from(t);
+    case 2:
+      return us(t) ? Uint16Array.from(t) : Int16Array.from(t);
+    case 4:
+      return Float32Array.from(t);
+    default:
+      return Float64Array.from(t);
+  }
+}
+function Ca(t, e) {
+  if (!t)
+    return !1;
+  const { size: r, data: s, indices: a } = t;
+  H(e, 0, 0, 0), H(Y, 0, 0, 0);
+  let i = 0, n = 0;
+  for (let o = 0; o < a.length - 2; o += 3) {
+    const c = a[o] * r, d = a[o + 1] * r, u = a[o + 2] * r;
+    H(z, s[c], s[c + 1], s[c + 2]), H(oe, s[d], s[d + 1], s[d + 2]), H(Ye, s[u], s[u + 1], s[u + 2]);
+    const h = Ps(z, oe, Ye);
+    h ? (ee(z, z, oe), ee(z, z, Ye), ae(z, z, 1 / 3 * h), ee(e, e, z), i += h) : (ee(Y, Y, z), ee(Y, Y, oe), ee(Y, Y, Ye), n += 3);
+  }
+  return (n !== 0 || i !== 0) && (i !== 0 ? (ae(e, e, 1 / i), !0) : n !== 0 && (ae(e, Y, 1 / n), !0));
+}
+function wa(t, e) {
+  if (!t)
+    return !1;
+  const { size: r, data: s, indices: a } = t;
+  H(e, 0, 0, 0);
+  let i = -1, n = 0;
+  for (let o = 0; o < a.length; o++) {
+    const c = a[o] * r;
+    i !== c && (e[0] += s[c], e[1] += s[c + 1], e[2] += s[c + 2], n++), i = c;
+  }
+  return n > 1 && ae(e, e, 1 / n), n > 0;
+}
+function Ma(t, e, r) {
+  if (!t)
+    return !1;
+  H(r, 0, 0, 0), H(Y, 0, 0, 0);
+  let s = 0, a = 0;
+  const { size: i, data: n, indices: o } = t, c = o.length - 1, d = c + (e ? 2 : 0);
+  for (let u = 0; u < d; u += 2) {
+    const h = u < c ? u + 1 : 0, v = o[u < c ? u : c] * i, O = o[h] * i;
+    z[0] = n[v], z[1] = n[v + 1], z[2] = n[v + 2], oe[0] = n[O], oe[1] = n[O + 1], oe[2] = n[O + 2], ae(z, ee(z, z, oe), 0.5);
+    const S = ds(z, oe);
+    S > 0 ? (ee(r, r, ae(z, z, S)), s += S) : s === 0 && (ee(Y, Y, z), a++);
+  }
+  return s !== 0 ? (ae(r, r, 1 / s), !0) : a !== 0 && (ae(r, Y, 1 / a), !0);
+}
+const z = b(), oe = b(), Ye = b(), Y = b();
+let Lo = class Mr extends yt {
+  constructor(e, r, s = null, a = xe.Mesh, i = null, n = -1) {
+    super(), this.material = e, this.mapPositions = s, this.type = a, this.objectAndLayerIdColor = i, this.edgeIndicesLength = n, this.visible = !0, this._attributes = /* @__PURE__ */ new Map(), this._boundingInfo = null;
+    for (const [o, c] of r)
+      this._attributes.set(o, { ...c, indices: Ms(c.indices) }), o === m.POSITION && (this.edgeIndicesLength = this.edgeIndicesLength < 0 ? this._attributes.get(o).indices.length : this.edgeIndicesLength);
+  }
+  instantiate(e = {}) {
+    const r = new Mr(e.material || this.material, [], this.mapPositions, this.type, this.objectAndLayerIdColor, this.edgeIndicesLength);
+    return this._attributes.forEach((s, a) => {
+      s.exclusive = !1, r._attributes.set(a, s);
+    }), r._boundingInfo = this._boundingInfo, r.transformation = e.transformation || this.transformation, r;
+  }
+  get attributes() {
+    return this._attributes;
+  }
+  getMutableAttribute(e) {
+    let r = this._attributes.get(e);
+    return r && !r.exclusive && (r = { ...r, exclusive: !0, data: ya(r.data) }, this._attributes.set(e, r)), r;
+  }
+  setAttributeData(e, r) {
+    const s = this._attributes.get(e);
+    s && this._attributes.set(e, { ...s, exclusive: !0, data: r });
+  }
+  get indexCount() {
+    const e = this._attributes.values().next().value.indices;
+    return (e == null ? void 0 : e.length) ?? 0;
+  }
+  get faceCount() {
+    return this.indexCount / 3;
+  }
+  get boundingInfo() {
+    return this._boundingInfo == null && (this._boundingInfo = this._calculateBoundingInfo()), this._boundingInfo;
+  }
+  computeAttachmentOrigin(e) {
+    return !!(this.type === xe.Mesh ? this._computeAttachmentOriginTriangles(e) : this.type === xe.Line ? this._computeAttachmentOriginLines(e) : this._computeAttachmentOriginPoints(e)) && (this._transformation != null && ye(e, e, this._transformation), !0);
+  }
+  _computeAttachmentOriginTriangles(e) {
+    const r = this.attributes.get(m.POSITION);
+    return Ca(r, e);
+  }
+  _computeAttachmentOriginLines(e) {
+    const r = this.attributes.get(m.POSITION);
+    return Ma(r, Na(this.material.parameters, r), e);
+  }
+  _computeAttachmentOriginPoints(e) {
+    const r = this.attributes.get(m.POSITION);
+    return wa(r, e);
+  }
+  invalidateBoundingInfo() {
+    this._boundingInfo = null;
+  }
+  _calculateBoundingInfo() {
+    const e = this.attributes.get(m.POSITION);
+    if (!e || e.indices.length === 0)
+      return null;
+    const r = this.type === xe.Mesh ? 3 : 1;
+    U(e.indices.length % r == 0, "Indexing error: " + e.indices.length + " not divisible by " + r);
+    const s = Ns(e.indices.length / r);
+    return new Fs(s, r, e);
+  }
+  get transformation() {
+    return this._transformation ?? rt;
+  }
+  set transformation(e) {
+    this._transformation = e && e !== rt ? ws(e) : null;
+  }
+  addHighlight() {
+    const e = new ks(ys.Highlight);
+    return this.highlights = js(this.highlights, e), e;
+  }
+  removeHighlight(e) {
+    this.highlights = qs(this.highlights, e);
+  }
+};
+function Na(t, e) {
+  return !(!("isClosed" in t) || !t.isClosed) && e.indices.length > 2;
+}
+let yo = class extends yt {
+  constructor(e, r) {
+    super(), this.type = xe.Material, this.supportsEdges = !1, this._visible = !0, this._renderPriority = 0, this._vertexAttributeLocations = Ea, this._pp0 = qe(0, 0, 1), this._pp1 = qe(0, 0, 0), this._parameters = Lr(e, r), this.validateParameters(this._parameters);
+  }
+  get parameters() {
+    return this._parameters;
+  }
+  update(e) {
+    return !1;
+  }
+  setParameters(e, r = !0) {
+    va(this._parameters, e) && (this.validateParameters(this._parameters), r && this.parametersChanged());
+  }
+  validateParameters(e) {
+  }
+  get visible() {
+    return this._visible;
+  }
+  set visible(e) {
+    e !== this._visible && (this._visible = e, this.parametersChanged());
+  }
+  shouldRender(e) {
+    return this.isVisible() && this.isVisibleForOutput(e.output) && (!this.parameters.isDecoration || e.bindParameters.decorations === Cs.ON) && (this.parameters.renderOccluded & e.renderOccludedMask) != 0;
+  }
+  isVisibleForOutput(e) {
+    return !0;
+  }
+  get renderPriority() {
+    return this._renderPriority;
+  }
+  set renderPriority(e) {
+    e !== this._renderPriority && (this._renderPriority = e, this.parametersChanged());
+  }
+  get vertexAttributeLocations() {
+    return this._vertexAttributeLocations;
+  }
+  isVisible() {
+    return this._visible;
+  }
+  parametersChanged() {
+    var e;
+    (e = this.repository) == null || e.materialChanged(this);
+  }
+  queryRenderOccludedState(e) {
+    return this.isVisible() && this.parameters.renderOccluded === e;
+  }
+  intersectDraped(e, r, s, a, i, n) {
+    return this._pp0[0] = this._pp1[0] = a[0], this._pp0[1] = this._pp1[1] = a[1], this.intersect(e, r, s, this._pp0, this._pp1, i);
+  }
+};
+var st;
+(function(t) {
+  t[t.None = 0] = "None", t[t.Occlude = 1] = "Occlude", t[t.Transparent = 2] = "Transparent", t[t.OccludeAndTransparent = 4] = "OccludeAndTransparent", t[t.OccludeAndTransparentStencil = 8] = "OccludeAndTransparentStencil", t[t.Opaque = 16] = "Opaque";
+})(st || (st = {}));
+let wo = class extends Me {
+  constructor() {
+    super(...arguments), this.renderOccluded = st.Occlude, this.isDecoration = !1;
+  }
+};
+var Kt, Qt;
+(function(t) {
+  t[t.Undefined = 0] = "Undefined", t[t.DefinedSize = 1] = "DefinedSize", t[t.DefinedScale = 2] = "DefinedScale";
+})(Kt || (Kt = {})), function(t) {
+  t[t.Undefined = 0] = "Undefined", t[t.DefinedAngle = 1] = "DefinedAngle";
+}(Qt || (Qt = {}));
+class Pa extends Me {
+  constructor(e) {
+    super(), this.vvSize = (e == null ? void 0 : e.size) ?? null, this.vvColor = (e == null ? void 0 : e.color) ?? null, this.vvOpacity = (e == null ? void 0 : e.opacity) ?? null;
+  }
+}
+function No(t, e, r) {
+  if (!e.vvSize)
+    return H(t, 1, 1, 1), t;
+  for (let s = 0; s < 3; ++s) {
+    const a = e.vvSize.offset[s] + r[0] * e.vvSize.factor[s];
+    t[s] = It(a, e.vvSize.minSize[s], e.vvSize.maxSize[s]);
+  }
+  return t;
+}
+let Po = class extends Pa {
+  constructor() {
+    super(...arguments), this.renderOccluded = st.Occlude, this.isDecoration = !1;
+  }
+};
+const ut = 8;
+let Fa = class extends j {
+  constructor(e, r) {
+    super(e, "mat4", R.Draw, (s, a, i) => s.setUniformMatrix4fv(e, r(a, i)));
+  }
+};
+function Da(t, e) {
+  e.instancedDoublePrecision ? t.constants.add("cameraPosition", "vec3", $t) : t.uniforms.add(new te("cameraPosition", (r, s) => H(Nr, s.camera.viewInverseTransposeMatrix[3] - r.origin[0], s.camera.viewInverseTransposeMatrix[7] - r.origin[1], s.camera.viewInverseTransposeMatrix[11] - r.origin[2])));
+}
+function Bo(t, e) {
+  if (!e.instancedDoublePrecision)
+    return void t.uniforms.add(new $e("proj", (s, a) => a.camera.projectionMatrix), new Fa("view", (s, a) => pt(Zt, a.camera.viewMatrix, s.origin)), new te("localOrigin", (s) => s.origin));
+  const r = (s) => H(Nr, s.camera.viewInverseTransposeMatrix[3], s.camera.viewInverseTransposeMatrix[7], s.camera.viewInverseTransposeMatrix[11]);
+  t.uniforms.add(new $e("proj", (s, a) => a.camera.projectionMatrix), new $e("view", (s, a) => pt(Zt, a.camera.viewMatrix, r(a))), new q("localOrigin", (s, a) => r(a)));
+}
+const Zt = Ae(), Nr = b();
+function Ba(t) {
+  t.uniforms.add(new $e("viewNormal", (e, r) => r.camera.viewInverseTransposeMatrix));
+}
+function Ho(t) {
+  t.uniforms.add(new Qs("pixelRatio", (e, r) => r.camera.pixelRatio / r.overlayStretch));
+}
+let xt = class extends Ta {
+  constructor() {
+    super(...arguments), this.instancedDoublePrecision = !1, this.hasModelTransformation = !1;
+  }
+};
+L([ke()], xt.prototype, "instancedDoublePrecision", void 0), L([ke()], xt.prototype, "hasModelTransformation", void 0);
+const Jt = Ne();
+function Vo(t, e) {
+  const r = e.hasModelTransformation, s = e.instancedDoublePrecision;
+  r && (t.vertex.uniforms.add(new $e("model", (i) => i.modelTransformation ?? rt)), t.vertex.uniforms.add(new ot("normalLocalOriginFromModel", (i) => (hs(Jt, i.modelTransformation ?? rt), Jt)))), e.instanced && s && (t.attributes.add(m.INSTANCEMODELORIGINHI, "vec3"), t.attributes.add(m.INSTANCEMODELORIGINLO, "vec3"), t.attributes.add(m.INSTANCEMODEL, "mat3"), t.attributes.add(m.INSTANCEMODELNORMAL, "mat3"));
+  const a = t.vertex;
+  s && (a.include(yr, e), a.uniforms.add(new te("viewOriginHi", (i, n) => Ds(H(Ke, n.camera.viewInverseTransposeMatrix[3], n.camera.viewInverseTransposeMatrix[7], n.camera.viewInverseTransposeMatrix[11]), Ke)), new te("viewOriginLo", (i, n) => Bs(H(Ke, n.camera.viewInverseTransposeMatrix[3], n.camera.viewInverseTransposeMatrix[7], n.camera.viewInverseTransposeMatrix[11]), Ke)))), a.code.add(l`
+    vec3 getVertexInLocalOriginSpace() {
+      return ${r ? s ? "(model * vec4(instanceModel * localPosition().xyz, 1.0)).xyz" : "(model * localPosition()).xyz" : s ? "instanceModel * localPosition().xyz" : "localPosition().xyz"};
+    }
+
+    vec3 subtractOrigin(vec3 _pos) {
+      ${s ? l`
+          // Negated inputs are intentionally the first two arguments. The other way around the obfuscation in dpAdd() stopped
+          // working for macOS 14+ and iOS 17+.
+          // Issue: https://devtopia.esri.com/WebGIS/arcgis-js-api/issues/56280
+          vec3 originDelta = dpAdd(-instanceModelOriginHi, -instanceModelOriginLo, viewOriginHi, viewOriginLo);
+          return _pos - originDelta;` : "return vpos;"}
+    }
+    `), a.code.add(l`
+    vec3 dpNormal(vec4 _normal) {
+      return normalize(${r ? s ? "normalLocalOriginFromModel * (instanceModelNormal * _normal.xyz)" : "normalLocalOriginFromModel * _normal.xyz" : s ? "instanceModelNormal * _normal.xyz" : "_normal.xyz"});
+    }
+    `), e.output === x.Normal && (Ba(a), a.code.add(l`
+    vec3 dpNormalView(vec4 _normal) {
+      return normalize((viewNormal * ${r ? s ? "vec4(normalLocalOriginFromModel * (instanceModelNormal * _normal.xyz), 1.0)" : "vec4(normalLocalOriginFromModel * _normal.xyz, 1.0)" : s ? "vec4(instanceModelNormal * _normal.xyz, 1.0)" : "_normal"}).xyz);
+    }
+    `)), e.hasVertexTangents && a.code.add(l`
+    vec4 dpTransformVertexTangent(vec4 _tangent) {
+      ${r ? s ? "return vec4(normalLocalOriginFromModel * (instanceModelNormal * _tangent.xyz), _tangent.w);" : "return vec4(normalLocalOriginFromModel * _tangent.xyz, _tangent.w);" : s ? "return vec4(instanceModelNormal * _tangent.xyz, _tangent.w);" : "return _tangent;"}
+    }`);
+}
+const Ke = b();
+let dt = class extends xt {
+};
+L([ke({ constValue: !0 })], dt.prototype, "hasSliceHighlight", void 0), L([ke({ constValue: !1 })], dt.prototype, "hasSliceInVertexProgram", void 0), L([ke({ constValue: R.Pass })], dt.prototype, "pbrTextureBindType", void 0);
+function er(t) {
+  t.varyings.add("linearDepth", "float");
+}
+function Ha(t) {
+  t.vertex.uniforms.add(new Ct("nearFar", (e, r) => r.camera.nearFar));
+}
+function Pr(t) {
+  t.vertex.code.add(l`float calculateLinearDepth(vec2 nearFar,float z) {
+return (-z - nearFar[0]) / (nearFar[1] - nearFar[0]);
+}`);
+}
+function Go(t, e) {
+  const { vertex: r } = t;
+  switch (e.output) {
+    case x.Color:
+      if (e.receiveShadows)
+        return er(t), void r.code.add(l`void forwardLinearDepth() { linearDepth = gl_Position.w; }`);
+      break;
+    case x.LinearDepth:
+    case x.Shadow:
+    case x.ShadowHighlight:
+    case x.ShadowExcludeHighlight:
+      return t.include(wr, e), er(t), Ha(t), Pr(t), void r.code.add(l`void forwardLinearDepth() {
+linearDepth = calculateLinearDepth(nearFar, vPosition_view.z);
+}`);
+  }
+  r.code.add(l`void forwardLinearDepth() {}`);
+}
+function Wo(t, e) {
+  Ua(t, e, new te("slicePlaneOrigin", (r, s) => Va(e, r, s)), new te("slicePlaneBasis1", (r, s) => {
+    var a;
+    return tr(e, r, s, (a = s.slicePlane) == null ? void 0 : a.basis1);
+  }), new te("slicePlaneBasis2", (r, s) => {
+    var a;
+    return tr(e, r, s, (a = s.slicePlane) == null ? void 0 : a.basis2);
+  }));
+}
+function Ua(t, e, ...r) {
+  if (!e.hasSlicePlane) {
+    const n = l`#define rejectBySlice(_pos_) false
+#define discardBySlice(_pos_) {}
+#define highlightSlice(_color_, _pos_) (_color_)`;
+    return e.hasSliceInVertexProgram && t.vertex.code.add(n), void t.fragment.code.add(n);
+  }
+  e.hasSliceInVertexProgram && t.vertex.uniforms.add(...r), t.fragment.uniforms.add(...r);
+  const s = l`struct SliceFactors {
+float front;
+float side0;
+float side1;
+float side2;
+float side3;
+};
+SliceFactors calculateSliceFactors(vec3 pos) {
+vec3 rel = pos - slicePlaneOrigin;
+vec3 slicePlaneNormal = -cross(slicePlaneBasis1, slicePlaneBasis2);
+float slicePlaneW = -dot(slicePlaneNormal, slicePlaneOrigin);
+float basis1Len2 = dot(slicePlaneBasis1, slicePlaneBasis1);
+float basis2Len2 = dot(slicePlaneBasis2, slicePlaneBasis2);
+float basis1Dot = dot(slicePlaneBasis1, rel);
+float basis2Dot = dot(slicePlaneBasis2, rel);
+return SliceFactors(
+dot(slicePlaneNormal, pos) + slicePlaneW,
+-basis1Dot - basis1Len2,
+basis1Dot - basis1Len2,
+-basis2Dot - basis2Len2,
+basis2Dot - basis2Len2
+);
+}
+bool sliceByFactors(SliceFactors factors) {
+return factors.front < 0.0
+&& factors.side0 < 0.0
+&& factors.side1 < 0.0
+&& factors.side2 < 0.0
+&& factors.side3 < 0.0;
+}
+bool sliceEnabled() {
+return dot(slicePlaneBasis1, slicePlaneBasis1) != 0.0;
+}
+bool sliceByPlane(vec3 pos) {
+return sliceEnabled() && sliceByFactors(calculateSliceFactors(pos));
+}
+#define rejectBySlice(_pos_) sliceByPlane(_pos_)
+#define discardBySlice(_pos_) { if (sliceByPlane(_pos_)) discard; }`, a = l`vec4 applySliceHighlight(vec4 color, vec3 pos) {
+SliceFactors factors = calculateSliceFactors(pos);
+const float HIGHLIGHT_WIDTH = 1.0;
+const vec4 HIGHLIGHT_COLOR = vec4(0.0, 0.0, 0.0, 0.3);
+factors.front /= (2.0 * HIGHLIGHT_WIDTH) * fwidth(factors.front);
+factors.side0 /= (2.0 * HIGHLIGHT_WIDTH) * fwidth(factors.side0);
+factors.side1 /= (2.0 * HIGHLIGHT_WIDTH) * fwidth(factors.side1);
+factors.side2 /= (2.0 * HIGHLIGHT_WIDTH) * fwidth(factors.side2);
+factors.side3 /= (2.0 * HIGHLIGHT_WIDTH) * fwidth(factors.side3);
+if (sliceByFactors(factors)) {
+return color;
+}
+float highlightFactor = (1.0 - step(0.5, factors.front))
+* (1.0 - step(0.5, factors.side0))
+* (1.0 - step(0.5, factors.side1))
+* (1.0 - step(0.5, factors.side2))
+* (1.0 - step(0.5, factors.side3));
+return mix(color, vec4(HIGHLIGHT_COLOR.rgb, color.a), highlightFactor * HIGHLIGHT_COLOR.a);
+}`, i = e.hasSliceHighlight ? l`
+        ${a}
+        #define highlightSlice(_color_, _pos_) (sliceEnabled() ? applySliceHighlight(_color_, _pos_) : (_color_))
+      ` : l`#define highlightSlice(_color_, _pos_) (_color_)`;
+  e.hasSliceInVertexProgram && t.vertex.code.add(s), t.fragment.code.add(s), t.fragment.code.add(i);
+}
+function Fr(t, e, r) {
+  return t.instancedDoublePrecision ? H(za, r.camera.viewInverseTransposeMatrix[3], r.camera.viewInverseTransposeMatrix[7], r.camera.viewInverseTransposeMatrix[11]) : e.slicePlaneLocalOrigin;
+}
+function Dr(t, e) {
+  return t != null ? lr(at, e.origin, t) : e.origin;
+}
+function Br(t, e, r) {
+  return t.hasSliceTranslatedView ? e != null ? pt(Ga, r.camera.viewMatrix, e) : r.camera.viewMatrix : null;
+}
+function Va(t, e, r) {
+  if (r.slicePlane == null)
+    return $t;
+  const s = Fr(t, e, r), a = Dr(s, r.slicePlane), i = Br(t, s, r);
+  return i != null ? ye(at, a, i) : a;
+}
+function tr(t, e, r, s) {
+  if (s == null || r.slicePlane == null)
+    return $t;
+  const a = Fr(t, e, r), i = Dr(a, r.slicePlane), n = Br(t, a, r);
+  return n != null ? (ee(He, s, i), ye(at, i, n), ye(He, He, n), lr(He, He, at)) : s;
+}
+const za = b(), at = b(), He = b(), Ga = Ae();
+function ko(t, e) {
+  const r = e.output === x.ObjectAndLayerIdColor, s = e.objectAndLayerIdColorInstanced;
+  r && (t.varyings.add("objectAndLayerIdColorVarying", "vec4"), s ? t.attributes.add(m.INSTANCEOBJECTANDLAYERIDCOLOR, "vec4") : t.attributes.add(m.OBJECTANDLAYERIDCOLOR, "vec4")), t.vertex.code.add(l`
+     void forwardObjectAndLayerIdColor() {
+      ${r ? s ? l`objectAndLayerIdColorVarying = instanceObjectAndLayerIdColor * 0.003921568627451;` : l`objectAndLayerIdColorVarying = objectAndLayerIdColor * 0.003921568627451;` : l``} }`), t.fragment.code.add(l`
+      void outputObjectAndLayerIdColor() {
+        ${r ? l`fragColor = objectAndLayerIdColorVarying;` : l``} }`);
+}
+let Wa = class extends j {
+  constructor(e, r, s) {
+    super(e, "vec4", R.Pass, (a, i, n) => a.setUniform4fv(e, r(i, n)), s);
+  }
+}, ka = class extends j {
+  constructor(e, r, s) {
+    super(e, "float", R.Pass, (a, i, n) => a.setUniform1fv(e, r(i, n)), s);
+  }
+};
+function Xo(t, e) {
+  const { vertex: r, attributes: s } = t;
+  e.hasVvInstancing && (e.vvSize || e.vvColor) && s.add(m.INSTANCEFEATUREATTRIBUTE, "vec4"), e.vvSize ? (r.uniforms.add(new q("vvSizeMinSize", (a) => a.vvSize.minSize)), r.uniforms.add(new q("vvSizeMaxSize", (a) => a.vvSize.maxSize)), r.uniforms.add(new q("vvSizeOffset", (a) => a.vvSize.offset)), r.uniforms.add(new q("vvSizeFactor", (a) => a.vvSize.factor)), r.uniforms.add(new ot("vvSymbolRotationMatrix", (a) => a.vvSymbolRotationMatrix)), r.uniforms.add(new q("vvSymbolAnchor", (a) => a.vvSymbolAnchor)), r.code.add(l`vec3 vvScale(vec4 _featureAttribute) {
+return clamp(vvSizeOffset + _featureAttribute.x * vvSizeFactor, vvSizeMinSize, vvSizeMaxSize);
+}
+vec4 vvTransformPosition(vec3 position, vec4 _featureAttribute) {
+return vec4(vvSymbolRotationMatrix * ( vvScale(_featureAttribute) * (position + vvSymbolAnchor)), 1.0);
+}`), r.code.add(l`
+      const float eps = 1.192092896e-07;
+      vec4 vvTransformNormal(vec3 _normal, vec4 _featureAttribute) {
+        vec3 vvScale = clamp(vvSizeOffset + _featureAttribute.x * vvSizeFactor, vvSizeMinSize + eps, vvSizeMaxSize);
+        return vec4(vvSymbolRotationMatrix * _normal / vvScale, 1.0);
+      }
+
+      ${e.hasVvInstancing ? l`
+      vec4 vvLocalNormal(vec3 _normal) {
+        return vvTransformNormal(_normal, instanceFeatureAttribute);
+      }
+
+      vec4 localPosition() {
+        return vvTransformPosition(position, instanceFeatureAttribute);
+      }` : ""}
+    `)) : r.code.add(l`vec4 localPosition() { return vec4(position, 1.0); }
+vec4 vvLocalNormal(vec3 _normal) { return vec4(_normal, 1.0); }`), e.vvColor ? (r.constants.add("vvColorNumber", "int", ut), r.uniforms.add(new ka("vvColorValues", (a) => a.vvColor.values, ut), new Wa("vvColorColors", (a) => a.vvColor.colors, ut)), r.code.add(l`
+      vec4 interpolateVVColor(float value) {
+        if (value <= vvColorValues[0]) {
+          return vvColorColors[0];
+        }
+
+        for (int i = 1; i < vvColorNumber; ++i) {
+          if (vvColorValues[i] >= value) {
+            float f = (value - vvColorValues[i-1]) / (vvColorValues[i] - vvColorValues[i-1]);
+            return mix(vvColorColors[i-1], vvColorColors[i], f);
+          }
+        }
+        return vvColorColors[vvColorNumber - 1];
+      }
+
+      vec4 vvGetColor(vec4 featureAttribute) {
+        return interpolateVVColor(featureAttribute.y);
+      }
+
+      ${e.hasVvInstancing ? l`
+            vec4 vvColor() {
+              return vvGetColor(instanceFeatureAttribute);
+            }` : "vec4 vvColor() { return vec4(1.0); }"}
+    `)) : r.code.add(l`vec4 vvColor() { return vec4(1.0); }`);
+}
+function ja(t) {
+  t.code.add(l`const float MAX_RGBA4_FLOAT =
+15.0 / 16.0 +
+15.0 / 16.0 / 16.0 +
+15.0 / 16.0 / 16.0 / 16.0 +
+15.0 / 16.0 / 16.0 / 16.0 / 16.0;
+const vec4 FIXED_POINT_FACTORS_RGBA4 = vec4(1.0, 16.0, 16.0 * 16.0, 16.0 * 16.0 * 16.0);
+vec4 floatToRgba4(const float value) {
+float valueInValidDomain = clamp(value, 0.0, MAX_RGBA4_FLOAT);
+vec4 fixedPointU4 = floor(fract(valueInValidDomain * FIXED_POINT_FACTORS_RGBA4) * 16.0);
+const float toU4AsFloat = 1.0 / 15.0;
+return fixedPointU4 * toU4AsFloat;
+}
+const vec4 RGBA4_2_FLOAT_FACTORS = vec4(
+15.0 / (16.0),
+15.0 / (16.0 * 16.0),
+15.0 / (16.0 * 16.0 * 16.0),
+15.0 / (16.0 * 16.0 * 16.0 * 16.0)
+);
+float rgba4ToFloat(vec4 rgba) {
+return dot(rgba, RGBA4_2_FLOAT_FACTORS);
+}`);
+}
+function Yo(t, e) {
+  switch (e.output) {
+    case x.Shadow:
+    case x.ShadowHighlight:
+    case x.ShadowExcludeHighlight:
+      t.fragment.include(ja), t.fragment.code.add(l`float _calculateFragDepth(const in float depth) {
+const float SLOPE_SCALE = 2.0;
+const float BIAS = 20.0 * .000015259;
+float m = max(abs(dFdx(depth)), abs(dFdy(depth)));
+return depth + SLOPE_SCALE * m + BIAS;
+}
+void outputDepth(float _linearDepth) {
+fragColor = floatToRgba4(_calculateFragDepth(_linearDepth));
+}`);
+      break;
+    case x.LinearDepth:
+      t.fragment.include(pr), t.fragment.code.add(l`void outputDepth(float _linearDepth) {
+fragColor = float2rgba(_linearDepth);
+}`);
+  }
+}
+function qa() {
+  if (ht == null) {
+    const t = (e) => ms(`esri/libs/basisu/${e}`);
+    ht = import("./basis_transcoder-292f1aaf.js").then((e) => e.b).then(({ default: e }) => e({ locateFile: t }).then((r) => (r.initializeBasis(), delete r.then, r)));
+  }
+  return ht;
+}
+let ht;
+var Ee;
+(function(t) {
+  t[t.ETC1_RGB = 0] = "ETC1_RGB", t[t.ETC2_RGBA = 1] = "ETC2_RGBA", t[t.BC1_RGB = 2] = "BC1_RGB", t[t.BC3_RGBA = 3] = "BC3_RGBA", t[t.BC4_R = 4] = "BC4_R", t[t.BC5_RG = 5] = "BC5_RG", t[t.BC7_M6_RGB = 6] = "BC7_M6_RGB", t[t.BC7_M5_RGBA = 7] = "BC7_M5_RGBA", t[t.PVRTC1_4_RGB = 8] = "PVRTC1_4_RGB", t[t.PVRTC1_4_RGBA = 9] = "PVRTC1_4_RGBA", t[t.ASTC_4x4_RGBA = 10] = "ASTC_4x4_RGBA", t[t.ATC_RGB = 11] = "ATC_RGB", t[t.ATC_RGBA = 12] = "ATC_RGBA", t[t.FXT1_RGB = 17] = "FXT1_RGB", t[t.PVRTC2_4_RGB = 18] = "PVRTC2_4_RGB", t[t.PVRTC2_4_RGBA = 19] = "PVRTC2_4_RGBA", t[t.ETC2_EAC_R11 = 20] = "ETC2_EAC_R11", t[t.ETC2_EAC_RG11 = 21] = "ETC2_EAC_RG11", t[t.RGBA32 = 13] = "RGBA32", t[t.RGB565 = 14] = "RGB565", t[t.BGR565 = 15] = "BGR565", t[t.RGBA4444 = 16] = "RGBA4444";
+})(Ee || (Ee = {}));
+let re = null, Qe = null;
+async function Hr() {
+  return Qe == null && (Qe = qa(), re = await Qe), Qe;
+}
+function Xa(t, e) {
+  if (re == null)
+    return t.byteLength;
+  const r = new re.BasisFile(new Uint8Array(t)), s = Vr(r) ? Ur(r.getNumLevels(0), r.getHasAlpha(), r.getImageWidth(0, 0), r.getImageHeight(0, 0), e) : 0;
+  return r.close(), r.delete(), s;
+}
+function Ya(t, e) {
+  if (re == null)
+    return t.byteLength;
+  const r = new re.KTX2File(new Uint8Array(t)), s = zr(r) ? Ur(r.getLevels(), r.getHasAlpha(), r.getWidth(), r.getHeight(), e) : 0;
+  return r.close(), r.delete(), s;
+}
+function Ur(t, e, r, s, a) {
+  const i = $s(e ? le.COMPRESSED_RGBA8_ETC2_EAC : le.COMPRESSED_RGB8_ETC2), n = a && t > 1 ? (4 ** t - 1) / (3 * 4 ** (t - 1)) : 1;
+  return Math.ceil(r * s * i * n);
+}
+function Vr(t) {
+  return t.getNumImages() >= 1 && !t.isUASTC();
+}
+function zr(t) {
+  return t.getFaces() >= 1 && t.isETC1S();
+}
+async function Ka(t, e, r) {
+  re == null && (re = await Hr());
+  const s = new re.BasisFile(new Uint8Array(r));
+  if (!Vr(s))
+    return null;
+  s.startTranscoding();
+  const a = Gr(t, e, s.getNumLevels(0), s.getHasAlpha(), s.getImageWidth(0, 0), s.getImageHeight(0, 0), (i, n) => s.getImageTranscodedSizeInBytes(0, i, n), (i, n, o) => s.transcodeImage(o, 0, i, n, 0, 0));
+  return s.close(), s.delete(), a;
+}
+async function Qa(t, e, r) {
+  re == null && (re = await Hr());
+  const s = new re.KTX2File(new Uint8Array(r));
+  if (!zr(s))
+    return null;
+  s.startTranscoding();
+  const a = Gr(t, e, s.getLevels(), s.getHasAlpha(), s.getWidth(), s.getHeight(), (i, n) => s.getImageTranscodedSizeInBytes(i, 0, 0, n), (i, n, o) => s.transcodeImage(o, i, 0, 0, n, 0, -1, -1));
+  return s.close(), s.delete(), a;
+}
+function Gr(t, e, r, s, a, i, n, o) {
+  const { compressedTextureETC: c, compressedTextureS3TC: d } = t.capabilities, [u, h] = c ? s ? [Ee.ETC2_RGBA, le.COMPRESSED_RGBA8_ETC2_EAC] : [Ee.ETC1_RGB, le.COMPRESSED_RGB8_ETC2] : d ? s ? [Ee.BC3_RGBA, le.COMPRESSED_RGBA_S3TC_DXT5_EXT] : [Ee.BC1_RGB, le.COMPRESSED_RGB_S3TC_DXT1_EXT] : [Ee.RGBA32, Re.RGBA], v = e.hasMipmap ? r : Math.min(1, r), O = [];
+  for (let S = 0; S < v; S++)
+    O.push(new Uint8Array(n(S, u))), o(S, u, O[S]);
+  return e.internalFormat = h, e.hasMipmap = O.length > 1, e.samplingMode = e.hasMipmap ? Ce.LINEAR_MIPMAP_LINEAR : Ce.LINEAR, e.width = a, e.height = i, new ze(t, e, { type: "compressed", levels: O });
+}
+const Ze = () => or.getLogger("esri.views.3d.webgl-engine.lib.DDSUtil"), Za = 542327876, Ja = 131072, ei = 4;
+function wt(t) {
+  return t.charCodeAt(0) + (t.charCodeAt(1) << 8) + (t.charCodeAt(2) << 16) + (t.charCodeAt(3) << 24);
+}
+function ti(t) {
+  return String.fromCharCode(255 & t, t >> 8 & 255, t >> 16 & 255, t >> 24 & 255);
+}
+const ri = wt("DXT1"), si = wt("DXT3"), ai = wt("DXT5"), ii = 31, ni = 0, oi = 1, ci = 2, li = 3, ui = 4, di = 7, hi = 20, mi = 21;
+function fi(t, e, r) {
+  const s = pi(r, e.hasMipmap ?? !1);
+  if (s == null)
+    throw new Error("DDS texture data is null");
+  const { textureData: a, internalFormat: i, width: n, height: o } = s;
+  return e.samplingMode = a.levels.length > 1 ? Ce.LINEAR_MIPMAP_LINEAR : Ce.LINEAR, e.hasMipmap = a.levels.length > 1, e.internalFormat = i, e.width = n, e.height = o, new ze(t, e, a);
+}
+function pi(t, e) {
+  const r = new Int32Array(t, 0, ii);
+  if (r[ni] !== Za)
+    return Ze().error("Invalid magic number in DDS header"), null;
+  if (!(r[hi] & ei))
+    return Ze().error("Unsupported format, must contain a FourCC code"), null;
+  const s = r[mi];
+  let a, i;
+  switch (s) {
+    case ri:
+      a = 8, i = le.COMPRESSED_RGB_S3TC_DXT1_EXT;
+      break;
+    case si:
+      a = 16, i = le.COMPRESSED_RGBA_S3TC_DXT3_EXT;
+      break;
+    case ai:
+      a = 16, i = le.COMPRESSED_RGBA_S3TC_DXT5_EXT;
+      break;
+    default:
+      return Ze().error("Unsupported FourCC code:", ti(s)), null;
+  }
+  let n = 1, o = r[ui], c = r[li];
+  !(3 & o) && !(3 & c) || (Ze().warn("Rounding up compressed texture size to nearest multiple of 4."), o = o + 3 & -4, c = c + 3 & -4);
+  const d = o, u = c;
+  let h, v;
+  r[ci] & Ja && e !== !1 && (n = Math.max(1, r[di]));
+  let O = r[oi] + 4;
+  const S = [];
+  for (let V = 0; V < n; ++V)
+    v = (o + 3 >> 2) * (c + 3 >> 2) * a, h = new Uint8Array(t, O, v), S.push(h), O += v, o = Math.max(1, o >> 1), c = Math.max(1, c >> 1);
+  return { textureData: { type: "compressed", levels: S }, internalFormat: i, width: d, height: u };
+}
+const it = 16;
+function Ko(t) {
+  return Math.ceil(t / it) * it;
+}
+function Qo(t) {
+  return Math.floor(t / it) * it;
+}
+function vi(t, e) {
+  let i = t.width * t.height;
+  if (i < 4096)
+    return t instanceof ImageData ? Wr(t) : t;
+  let n = t.width, o = t.height;
+  do
+    n = Math.ceil(n / 2), o = Math.ceil(o / 2), i = n * o;
+  while (i > 1048576 || e != null && (n > e || o > e));
+  return Mt(t, n, o);
+}
+function _i(t, e) {
+  const r = Math.max(t.width, t.height);
+  if (r <= e)
+    return t;
+  const s = e / r;
+  return Mt(t, Math.round(t.width * s), Math.round(t.height * s));
+}
+function Mt(t, e, r) {
+  if (t instanceof ImageData)
+    return Mt(Wr(t), e, r);
+  const s = document.createElement("canvas");
+  return s.width = e, s.height = r, s.getContext("2d").drawImage(t, 0, 0, s.width, s.height), s;
+}
+function Wr(t) {
+  const e = document.createElement("canvas");
+  e.width = t.width, e.height = t.height;
+  const r = e.getContext("2d");
+  if (r == null)
+    throw new bt("Failed to create 2d context from HTMLCanvasElement");
+  return r.putImageData(t, 0, 0), e;
+}
+let Zo = class extends yt {
+  get parameters() {
+    return this._parameters;
+  }
+  constructor(e, r) {
+    super(), this._data = e, this.type = xe.Texture, this._glTexture = null, this._loadingPromise = null, this._loadingController = null, this.events = new fs(), this._parameters = { ...Ti, ...r }, this._startPreload(e);
+  }
+  dispose() {
+    this.unload(), this._data = this.frameUpdate = void 0;
+  }
+  _startPreload(e) {
+    e != null && (e instanceof HTMLVideoElement ? (this.frameUpdate = (r) => this._frameUpdate(e, r), this._startPreloadVideoElement(e)) : e instanceof HTMLImageElement && this._startPreloadImageElement(e));
+  }
+  _startPreloadVideoElement(e) {
+    if (!(Ft(e.src) || e.preload === "auto" && e.crossOrigin)) {
+      e.preload = "auto", e.crossOrigin = "anonymous";
+      const r = !e.paused;
+      if (e.src = e.src, r && e.autoplay) {
+        const s = () => {
+          e.removeEventListener("canplay", s), e.play();
+        };
+        e.addEventListener("canplay", s);
+      }
+    }
+  }
+  _startPreloadImageElement(e) {
+    ps(e.src) || Ft(e.src) || e.crossOrigin || (e.crossOrigin = "anonymous", e.src = e.src);
+  }
+  _createDescriptor(e) {
+    const r = new Ls();
+    return r.wrapMode = this._parameters.wrap ?? vt.REPEAT, r.flipped = !this._parameters.noUnpackFlip, r.samplingMode = this._parameters.mipmap ? Ce.LINEAR_MIPMAP_LINEAR : Ce.LINEAR, r.hasMipmap = !!this._parameters.mipmap, r.preMultiplyAlpha = !!this._parameters.preMultiplyAlpha, r.maxAnisotropy = this._parameters.maxAnisotropy ?? (this._parameters.mipmap ? e.parameters.maxMaxAnisotropy : 1), r;
+  }
+  get glTexture() {
+    return this._glTexture;
+  }
+  get memoryEstimate() {
+    var e;
+    return ((e = this._glTexture) == null ? void 0 : e.usedMemory) || gi(this._data, this._parameters);
+  }
+  load(e) {
+    if (this._glTexture)
+      return this._glTexture;
+    if (this._loadingPromise)
+      return this._loadingPromise;
+    const r = this._data;
+    return r == null ? (this._glTexture = new ze(e, this._createDescriptor(e), null), this._glTexture) : (this._parameters.reloadable || (this._data = void 0), typeof r == "string" ? this._loadFromURL(e, r) : r instanceof Image ? this._loadFromImageElement(e, r) : r instanceof HTMLVideoElement ? this._loadFromVideoElement(e, r) : r instanceof ImageData || r instanceof HTMLCanvasElement ? this._loadFromImage(e, r) : (Ue(r) || Ve(r)) && this._parameters.encoding === Ge.DDS_ENCODING ? this._loadFromDDSData(e, r) : (Ue(r) || Ve(r)) && this._parameters.encoding === Ge.KTX2_ENCODING ? this._loadFromKTX2(e, r) : (Ue(r) || Ve(r)) && this._parameters.encoding === Ge.BASIS_ENCODING ? this._loadFromBasis(e, r) : Ve(r) ? this._loadFromPixelData(e, r) : Ue(r) ? this._loadFromPixelData(e, new Uint8Array(r)) : null);
+  }
+  _frameUpdate(e, r) {
+    return this._glTexture == null || e.readyState < je.HAVE_CURRENT_DATA || r === e.currentTime ? r : (this._glTexture.setData(e), this._glTexture.descriptor.hasMipmap && this._glTexture.generateMipmap(), this._parameters.updateCallback && this._parameters.updateCallback(), e.currentTime);
+  }
+  _loadFromDDSData(e, r) {
+    return this._glTexture = fi(e, this._createDescriptor(e), r), this._glTexture;
+  }
+  _loadFromKTX2(e, r) {
+    return this._loadAsync(() => Qa(e, this._createDescriptor(e), r).then((s) => (this._glTexture = s, s)));
+  }
+  _loadFromBasis(e, r) {
+    return this._loadAsync(() => Ka(e, this._createDescriptor(e), r).then((s) => (this._glTexture = s, s)));
+  }
+  _loadFromPixelData(e, r) {
+    U(this._parameters.width > 0 && this._parameters.height > 0);
+    const s = this._createDescriptor(e);
+    return s.pixelFormat = this._parameters.components === 1 ? Re.LUMINANCE : this._parameters.components === 3 ? Re.RGB : Re.RGBA, s.width = this._parameters.width ?? 0, s.height = this._parameters.height ?? 0, this._glTexture = new ze(e, s, r), this._glTexture;
+  }
+  _loadFromURL(e, r) {
+    return this._loadAsync(async (s) => {
+      const a = await Hs(r, { signal: s });
+      return Dt(s), this._loadFromImage(e, a);
+    });
+  }
+  _loadFromImageElement(e, r) {
+    return r.complete ? this._loadFromImage(e, r) : this._loadAsync(async (s) => {
+      const a = await vs(r, r.src, !1, s);
+      return Dt(s), this._loadFromImage(e, a);
+    });
+  }
+  _loadFromVideoElement(e, r) {
+    return r.readyState >= je.HAVE_CURRENT_DATA ? this._loadFromImage(e, r) : this._loadFromVideoElementAsync(e, r);
+  }
+  _loadFromVideoElementAsync(e, r) {
+    return this._loadAsync((s) => new Promise((a, i) => {
+      const n = () => {
+        r.removeEventListener("loadeddata", o), r.removeEventListener("error", c), Ts(d);
+      }, o = () => {
+        r.readyState >= je.HAVE_CURRENT_DATA && (n(), a(this._loadFromImage(e, r)));
+      }, c = (u) => {
+        n(), i(u || new bt("Failed to load video"));
+      };
+      r.addEventListener("loadeddata", o), r.addEventListener("error", c);
+      const d = _s(s, () => c(gs()));
+    }));
+  }
+  _loadFromImage(e, r) {
+    let s = r;
+    if (!(s instanceof HTMLVideoElement)) {
+      const { maxTextureSize: n } = e.parameters;
+      s = this._parameters.downsampleUncompressed ? vi(s, n) : _i(s, n);
+    }
+    const a = kr(s);
+    this._parameters.width = a.width, this._parameters.height = a.height;
+    const i = this._createDescriptor(e);
+    return i.pixelFormat = this._parameters.components === 3 ? Re.RGB : Re.RGBA, i.width = a.width, i.height = a.height, this._glTexture = new ze(e, i, s), this._glTexture;
+  }
+  _loadAsync(e) {
+    const r = new AbortController();
+    this._loadingController = r;
+    const s = e(r.signal);
+    this._loadingPromise = s;
+    const a = () => {
+      this._loadingController === r && (this._loadingController = null), this._loadingPromise === s && (this._loadingPromise = null);
+    };
+    return s.then(a, a), s;
+  }
+  unload() {
+    if (this._glTexture = ft(this._glTexture), this._loadingController != null) {
+      const e = this._loadingController;
+      this._loadingController = null, this._loadingPromise = null, e.abort();
+    }
+    this.events.emit("unloaded");
+  }
+};
+function gi(t, e) {
+  if (t == null)
+    return 0;
+  if (Ue(t) || Ve(t))
+    return e.encoding === Ge.KTX2_ENCODING ? Ya(t, !!e.mipmap) : e.encoding === Ge.BASIS_ENCODING ? Xa(t, !!e.mipmap) : t.byteLength;
+  const { width: r, height: s } = t instanceof Image || t instanceof ImageData || t instanceof HTMLCanvasElement || t instanceof HTMLVideoElement ? kr(t) : e;
+  return (e.mipmap ? 4 / 3 : 1) * r * s * (e.components || 4) || 0;
+}
+function kr(t) {
+  return t instanceof HTMLVideoElement ? { width: t.videoWidth, height: t.videoHeight } : t;
+}
+var je;
+(function(t) {
+  t[t.HAVE_NOTHING = 0] = "HAVE_NOTHING", t[t.HAVE_METADATA = 1] = "HAVE_METADATA", t[t.HAVE_CURRENT_DATA = 2] = "HAVE_CURRENT_DATA", t[t.HAVE_FUTURE_DATA = 3] = "HAVE_FUTURE_DATA", t[t.HAVE_ENOUGH_DATA = 4] = "HAVE_ENOUGH_DATA";
+})(je || (je = {}));
+const Ti = { wrap: { s: vt.REPEAT, t: vt.REPEAT }, mipmap: !0, noUnpackFlip: !1, preMultiplyAlpha: !1, downsampleUncompressed: !1 };
+function ec(t, e) {
+  if (!e.multipassEnabled)
+    return;
+  t.fragment.include(Xs), t.fragment.uniforms.add(new We("terrainDepthTexture", (s, a) => {
+    var i;
+    return (i = a.multipassTerrain.linearDepth) == null ? void 0 : i.getTexture();
+  }), new Ct("nearFar", (s, a) => a.camera.nearFar));
+  const r = e.occlusionPass;
+  t.fragment.code.add(l`
+   ${r ? "bool" : "void"} terrainDepthTest(float fragmentDepth) {
+      vec4 data = texelFetch(terrainDepthTexture, ivec2(gl_FragCoord.xy), 0);
+      float linearDepth = linearDepthFromRGBA(data, nearFar);
+      ${r ? l`return fragmentDepth < linearDepth && data != vec4(0.0, 0.0, 0.0, 1.0);` : l`
+          if(fragmentDepth ${e.cullAboveGround ? ">" : "<="} linearDepth){
+            discard;
+          }`}
+    }`);
+}
+let tc = class {
+  constructor() {
+    this.cullAboveGround = !1;
+  }
+};
+const sc = 0.1, ac = 1e-3;
+function ic(t) {
+  t.code.add(l`vec4 premultiplyAlpha(vec4 v) {
+return vec4(v.rgb * v.a, v.a);
+}
+vec3 rgb2hsv(vec3 c) {
+vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
+vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
+float d = q.x - min(q.w, q.y);
+float e = 1.0e-10;
+return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), min(d / (q.x + e), 1.0), q.x);
+}
+vec3 hsv2rgb(vec3 c) {
+vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+float rgb2v(vec3 c) {
+return max(c.x, max(c.y, c.z));
+}`);
+}
+const nc = { func: we.LESS }, oc = { func: we.ALWAYS }, cc = { mask: 255 }, lc = { mask: 0 }, uc = { function: { func: we.ALWAYS, ref: he.OutlineVisualElementMask, mask: he.OutlineVisualElementMask }, operation: { fail: Z.KEEP, zFail: Z.KEEP, zPass: Z.ZERO } }, dc = { function: { func: we.ALWAYS, ref: he.OutlineVisualElementMask, mask: he.OutlineVisualElementMask }, operation: { fail: Z.KEEP, zFail: Z.KEEP, zPass: Z.REPLACE } }, hc = { function: { func: we.EQUAL, ref: he.OutlineVisualElementMask, mask: he.OutlineVisualElementMask }, operation: { fail: Z.KEEP, zFail: Z.KEEP, zPass: Z.KEEP } }, mc = { function: { func: we.NOTEQUAL, ref: he.OutlineVisualElementMask, mask: he.OutlineVisualElementMask }, operation: { fail: Z.KEEP, zFail: Z.KEEP, zPass: Z.KEEP } };
+let Ei = class {
+  constructor(e = b()) {
+    this.intensity = e;
+  }
+}, Si = class {
+  constructor(e = b(), r = qe(0.57735, 0.57735, 0.57735)) {
+    this.intensity = e, this.direction = r;
+  }
+};
+class Ot {
+  constructor(e = b(), r = qe(0.57735, 0.57735, 0.57735), s = !0, a = 1, i = 1) {
+    this.intensity = e, this.direction = r, this.castShadows = s, this.specularStrength = a, this.environmentStrength = i;
+  }
+}
+let jr = class {
+  constructor() {
+    this.r = [0], this.g = [0], this.b = [0];
+  }
+};
+function Ai(t, e, r) {
+  (r = r || t).length = t.length;
+  for (let s = 0; s < t.length; s++)
+    r[s] = t[s] * e[s];
+  return r;
+}
+function mt(t, e, r) {
+  (r = r || t).length = t.length;
+  for (let s = 0; s < t.length; s++)
+    r[s] = t[s] * e;
+  return r;
+}
+function Le(t, e, r) {
+  (r = r || t).length = t.length;
+  for (let s = 0; s < t.length; s++)
+    r[s] = t[s] + e[s];
+  return r;
+}
+function qr(t) {
+  return (t + 1) * (t + 1);
+}
+function xi(t) {
+  return It(Math.floor(Math.sqrt(t) - 1), 0, 2);
+}
+function Xr(t, e, r) {
+  const s = t[0], a = t[1], i = t[2], n = r || [];
+  return n.length = qr(e), e >= 0 && (n[0] = 0.28209479177), e >= 1 && (n[1] = 0.4886025119 * s, n[2] = 0.4886025119 * i, n[3] = 0.4886025119 * a), e >= 2 && (n[4] = 1.09254843059 * s * a, n[5] = 1.09254843059 * a * i, n[6] = 0.31539156525 * (3 * i * i - 1), n[7] = 1.09254843059 * s * i, n[8] = 0.54627421529 * (s * s - a * a)), n;
+}
+function Oi(t, e) {
+  const r = qr(t), s = e || { r: [], g: [], b: [] };
+  s.r.length = s.g.length = s.b.length = r;
+  for (let a = 0; a < r; a++)
+    s.r[a] = s.g[a] = s.b[a] = 0;
+  return s;
+}
+function Ri(t, e) {
+  const r = xi(e.r.length);
+  for (const s of t)
+    Es(Rt, s.direction), Xr(Rt, r, ce), Ai(ce, tt), mt(ce, s.intensity[0], Oe), Le(e.r, Oe), mt(ce, s.intensity[1], Oe), Le(e.g, Oe), mt(ce, s.intensity[2], Oe), Le(e.b, Oe);
+  return e;
+}
+function bi(t, e) {
+  Xr(Rt, 0, ce);
+  for (const r of t)
+    e.r[0] += ce[0] * tt[0] * r.intensity[0] * 4 * Math.PI, e.g[0] += ce[0] * tt[0] * r.intensity[1] * 4 * Math.PI, e.b[0] += ce[0] * tt[0] * r.intensity[2] * 4 * Math.PI;
+  return e;
+}
+function Ii(t, e, r, s) {
+  Oi(e, s), H(r.intensity, 0, 0, 0);
+  let a = !1;
+  const i = $i, n = Li, o = yi;
+  i.length = 0, n.length = 0, o.length = 0;
+  for (const c of t)
+    c instanceof Ot && !a ? (Te(r.direction, c.direction), Te(r.intensity, c.intensity), r.specularStrength = c.specularStrength, r.environmentStrength = c.environmentStrength, r.castShadows = c.castShadows, a = !0) : c instanceof Ot || c instanceof Si ? i.push(c) : c instanceof Ei ? n.push(c) : c instanceof jr && o.push(c);
+  Ri(i, s), bi(n, s);
+  for (const c of o)
+    Le(s.r, c.r), Le(s.g, c.g), Le(s.b, c.b);
+}
+const $i = [], Li = [], yi = [], ce = [0], Oe = [0], Rt = b(), tt = [3.141593, 2.094395, 2.094395, 2.094395, 0.785398, 0.785398, 0.785398, 0.785398, 0.785398];
+class rr {
+  constructor() {
+    this.color = b(), this.intensity = 1;
+  }
+}
+class Ci {
+  constructor() {
+    this.direction = b(), this.ambient = new rr(), this.diffuse = new rr();
+  }
+}
+const wi = 0.4;
+class _c {
+  constructor() {
+    this._shOrder = 2, this._legacy = new Ci(), this.globalFactor = 0.5, this.noonFactor = 0.5, this._sphericalHarmonics = new jr(), this._mainLight = new Ot(b(), qe(1, 0, 0), !1);
+  }
+  get legacy() {
+    return this._legacy;
+  }
+  get sh() {
+    return this._sphericalHarmonics;
+  }
+  get mainLight() {
+    return this._mainLight;
+  }
+  set(e) {
+    Ii(e, this._shOrder, this._mainLight, this._sphericalHarmonics), Te(this._legacy.direction, this._mainLight.direction);
+    const r = 1 / Math.PI;
+    this._legacy.ambient.color[0] = 0.282095 * this._sphericalHarmonics.r[0] * r, this._legacy.ambient.color[1] = 0.282095 * this._sphericalHarmonics.g[0] * r, this._legacy.ambient.color[2] = 0.282095 * this._sphericalHarmonics.b[0] * r, ae(this._legacy.diffuse.color, this._mainLight.intensity, r), Te(Je, this._legacy.diffuse.color), ae(Je, Je, wi * this.globalFactor), ee(this._legacy.ambient.color, this._legacy.ambient.color, Je);
+  }
+  copyFrom(e) {
+    this._sphericalHarmonics.r = Array.from(e.sh.r), this._sphericalHarmonics.g = Array.from(e.sh.g), this._sphericalHarmonics.b = Array.from(e.sh.b), Te(this._mainLight.direction, e.mainLight.direction), Te(this._mainLight.intensity, e.mainLight.intensity), this._mainLight.castShadows = e.mainLight.castShadows, this._mainLight.specularStrength = e.mainLight.specularStrength, this._mainLight.environmentStrength = e.mainLight.environmentStrength, this.globalFactor = e.globalFactor, this.noonFactor = e.noonFactor;
+  }
+  lerpLighting(e, r, s) {
+    if (Ss(this._mainLight.intensity, e.mainLight.intensity, r.mainLight.intensity, s), this._mainLight.environmentStrength = ue(e.mainLight.environmentStrength, r.mainLight.environmentStrength, s), this._mainLight.specularStrength = ue(e.mainLight.specularStrength, r.mainLight.specularStrength, s), Te(this._mainLight.direction, r.mainLight.direction), this._mainLight.castShadows = r.mainLight.castShadows, this.globalFactor = ue(e.globalFactor, r.globalFactor, s), this.noonFactor = ue(e.noonFactor, r.noonFactor, s), e.sh.r.length === r.sh.r.length)
+      for (let a = 0; a < r.sh.r.length; a++)
+        this._sphericalHarmonics.r[a] = ue(e.sh.r[a], r.sh.r[a], s), this._sphericalHarmonics.g[a] = ue(e.sh.g[a], r.sh.g[a], s), this._sphericalHarmonics.b[a] = ue(e.sh.b[a], r.sh.b[a], s);
+    else
+      for (let a = 0; a < r.sh.r.length; a++)
+        this._sphericalHarmonics.r[a] = r.sh.r[a], this._sphericalHarmonics.g[a] = r.sh.g[a], this._sphericalHarmonics.b[a] = r.sh.b[a];
+  }
+}
+const Je = b();
+class gc {
+  constructor() {
+    this._transform = Ae(), this._transformInverse = new et({ value: this._transform }, xs, Ae), this._transformInverseTranspose = new et(this._transformInverse, Bt, Ae), this._transformTranspose = new et({ value: this._transform }, Bt, Ae), this._transformInverseRotation = new et({ value: this._transform }, Os, Ne);
+  }
+  _invalidateLazyTransforms() {
+    this._transformInverse.invalidate(), this._transformInverseTranspose.invalidate(), this._transformTranspose.invalidate(), this._transformInverseRotation.invalidate();
+  }
+  get transform() {
+    return this._transform;
+  }
+  get inverse() {
+    return this._transformInverse.value;
+  }
+  get inverseTranspose() {
+    return this._transformInverseTranspose.value;
+  }
+  get inverseRotation() {
+    return this._transformInverseRotation.value;
+  }
+  get transpose() {
+    return this._transformTranspose.value;
+  }
+  setTransformMatrix(e) {
+    Ht(this._transform, e);
+  }
+  multiplyTransform(e) {
+    Rs(this._transform, this._transform, e);
+  }
+  set(e) {
+    Ht(this._transform, e), this._invalidateLazyTransforms();
+  }
+  setAndInvalidateLazyTransforms(e, r) {
+    this.setTransformMatrix(e), this.multiplyTransform(r), this._invalidateLazyTransforms();
+  }
+}
+let et = class {
+  constructor(e, r, s) {
+    this._original = e, this._update = r, this._dirty = !0, this._transform = s();
+  }
+  invalidate() {
+    this._dirty = !0;
+  }
+  get value() {
+    return this._dirty && (this._update(this._transform, this._original.value), this._dirty = !1), this._transform;
+  }
+};
+class Mi {
+  constructor(e = 0) {
+    this.componentLocalOriginLength = 0, this._totalOffset = 0, this._offset = 0, this._tmpVertex = b(), this._tmpMbs = mr(), this._tmpObb = new Us(), this._resetOffset(e);
+  }
+  _resetOffset(e) {
+    this._offset = e, this._totalOffset = e;
+  }
+  set offset(e) {
+    this._resetOffset(e);
+  }
+  get offset() {
+    return this._offset;
+  }
+  set componentOffset(e) {
+    this._totalOffset = this._offset + e;
+  }
+  set localOrigin(e) {
+    this.componentLocalOriginLength = Se(e);
+  }
+  applyToVertex(e, r, s) {
+    const a = H(Yr, e, r, s), i = H(Pi, e, r, s + this.componentLocalOriginLength), n = this._totalOffset / Se(i);
+    return be(this._tmpVertex, a, i, n), this._tmpVertex;
+  }
+  applyToAabb(e) {
+    const r = this.componentLocalOriginLength, s = e[0], a = e[1], i = e[2] + r, n = e[3], o = e[4], c = e[5] + r, d = Math.abs(s), u = Math.abs(a), h = Math.abs(i), v = Math.abs(n), O = Math.abs(o), S = Math.abs(c), V = 0.5 * (1 + Math.sign(s * n)) * Math.min(d, v), G = 0.5 * (1 + Math.sign(a * o)) * Math.min(u, O), F = 0.5 * (1 + Math.sign(i * c)) * Math.min(h, S), k = Math.max(d, v), y = Math.max(u, O), I = Math.max(h, S), C = Math.sqrt(V * V + G * G + F * F), w = Math.sign(d + s), T = Math.sign(u + a), E = Math.sign(h + i), A = Math.sign(v + n), g = Math.sign(O + o), f = Math.sign(S + c), p = this._totalOffset;
+    if (C < p)
+      return e[0] -= (1 - w) * p, e[1] -= (1 - T) * p, e[2] -= (1 - E) * p, e[3] += A * p, e[4] += g * p, e[5] += f * p, e;
+    const _ = p / Math.sqrt(k * k + y * y + I * I), $ = p / C, N = $ - _, P = -N;
+    return e[0] += s * (w * P + $), e[1] += a * (T * P + $), e[2] += i * (E * P + $), e[3] += n * (A * N + _), e[4] += o * (g * N + _), e[5] += c * (f * N + _), e;
+  }
+  applyToMbs(e) {
+    const r = Se(de(e)), s = this._totalOffset / r;
+    return be(de(this._tmpMbs), de(e), de(e), s), this._tmpMbs[3] = e[3] + e[3] * this._totalOffset / r, this._tmpMbs;
+  }
+  applyToObb(e) {
+    return Vs(e, this._totalOffset, this._totalOffset, As.Global, this._tmpObb), this._tmpObb;
+  }
+}
+let Ni = class {
+  constructor(e = 0) {
+    this.offset = e, this.sphere = mr(), this.tmpVertex = b();
+  }
+  applyToVertex(e, r, s) {
+    const a = this.objectTransform.transform, i = H(Yr, e, r, s), n = ye(i, i, a), o = this.offset / Se(n);
+    be(n, n, n, o);
+    const c = this.objectTransform.inverse;
+    return ye(this.tmpVertex, n, c), this.tmpVertex;
+  }
+  applyToMinMax(e, r) {
+    const s = this.offset / Se(e);
+    be(e, e, e, s);
+    const a = this.offset / Se(r);
+    be(r, r, r, a);
+  }
+  applyToAabb(e) {
+    const r = this.offset / Math.sqrt(e[0] * e[0] + e[1] * e[1] + e[2] * e[2]);
+    e[0] += e[0] * r, e[1] += e[1] * r, e[2] += e[2] * r;
+    const s = this.offset / Math.sqrt(e[3] * e[3] + e[4] * e[4] + e[5] * e[5]);
+    return e[3] += e[3] * s, e[4] += e[4] * s, e[5] += e[5] * s, e;
+  }
+  applyToBoundingSphere(e) {
+    const r = Se(de(e)), s = this.offset / r;
+    return be(de(this.sphere), de(e), de(e), s), this.sphere[3] = e[3] + e[3] * this.offset / r, this.sphere;
+  }
+};
+const sr = new Ni();
+function Sc(t) {
+  return t != null ? (sr.offset = t, sr) : null;
+}
+new Mi();
+const Ac = "terrain", Yr = b(), Pi = b();
+let xc = class extends j {
+  constructor(e, r) {
+    super(e, "int", R.Pass, (s, a, i) => s.setUniform1i(e, r(a, i)));
+  }
+};
+function Fi(t) {
+  t.vertex.code.add(l`float screenSizePerspectiveViewAngleDependentFactor(float absCosAngle) {
+return absCosAngle * absCosAngle * absCosAngle;
+}`), t.vertex.code.add(l`vec3 screenSizePerspectiveScaleFactor(float absCosAngle, float distanceToCamera, vec3 params) {
+return vec3(
+min(params.x / (distanceToCamera - params.y), 1.0),
+screenSizePerspectiveViewAngleDependentFactor(absCosAngle),
+params.z
+);
+}`), t.vertex.code.add(l`float applyScreenSizePerspectiveScaleFactorFloat(float size, vec3 factor) {
+return mix(size * clamp(factor.x, factor.z, 1.0), size, factor.y);
+}`), t.vertex.code.add(l`float screenSizePerspectiveScaleFloat(float size, float absCosAngle, float distanceToCamera, vec3 params) {
+return applyScreenSizePerspectiveScaleFactorFloat(
+size,
+screenSizePerspectiveScaleFactor(absCosAngle, distanceToCamera, params)
+);
+}`), t.vertex.code.add(l`vec2 applyScreenSizePerspectiveScaleFactorVec2(vec2 size, vec3 factor) {
+return mix(size * clamp(factor.x, factor.z, 1.0), size, factor.y);
+}`), t.vertex.code.add(l`vec2 screenSizePerspectiveScaleVec2(vec2 size, float absCosAngle, float distanceToCamera, vec3 params) {
+return applyScreenSizePerspectiveScaleFactorVec2(size, screenSizePerspectiveScaleFactor(absCosAngle, distanceToCamera, params));
+}`);
+}
+function Rc(t) {
+  t.uniforms.add(new q("screenSizePerspective", (e) => Kr(e.screenSizePerspective)));
+}
+function Di(t) {
+  t.uniforms.add(new q("screenSizePerspectiveAlignment", (e) => Kr(e.screenSizePerspectiveAlignment || e.screenSizePerspective)));
+}
+function Kr(t) {
+  return H(Bi, t.parameters.divisor, t.parameters.offset, t.minScaleFactor);
+}
+const Bi = b();
+function bc(t, e) {
+  const r = t.vertex;
+  e.hasVerticalOffset ? (Ui(r), e.hasScreenSizePerspective && (t.include(Fi), Di(r), Da(t.vertex, e)), r.code.add(l`
+      vec3 calculateVerticalOffset(vec3 worldPos, vec3 localOrigin) {
+        float viewDistance = length((view * vec4(worldPos, 1.0)).xyz);
+        ${e.spherical ? l`vec3 worldNormal = normalize(worldPos + localOrigin);` : l`vec3 worldNormal = vec3(0.0, 0.0, 1.0);`}
+        ${e.hasScreenSizePerspective ? l`
+            float cosAngle = dot(worldNormal, normalize(worldPos - cameraPosition));
+            float verticalOffsetScreenHeight = screenSizePerspectiveScaleFloat(verticalOffset.x, abs(cosAngle), viewDistance, screenSizePerspectiveAlignment);` : l`
+            float verticalOffsetScreenHeight = verticalOffset.x;`}
+        // Screen sized offset in world space, used for example for line callouts
+        float worldOffset = clamp(verticalOffsetScreenHeight * verticalOffset.y * viewDistance, verticalOffset.z, verticalOffset.w);
+        return worldNormal * worldOffset;
+      }
+
+      vec3 addVerticalOffset(vec3 worldPos, vec3 localOrigin) {
+        return worldPos + calculateVerticalOffset(worldPos, localOrigin);
+      }
+    `)) : r.code.add(l`vec3 addVerticalOffset(vec3 worldPos, vec3 localOrigin) { return worldPos; }`);
+}
+const Hi = Lt();
+function Ui(t) {
+  t.uniforms.add(new vr("verticalOffset", (e, r) => {
+    const { minWorldLength: s, maxWorldLength: a, screenLength: i } = e.verticalOffset, n = Math.tan(0.5 * r.camera.fovY) / (0.5 * r.camera.fullViewport[3]), o = r.camera.pixelRatio || 1;
+    return _t(Hi, i * o, n, s, a);
+  }));
+}
+function ar(t, e, r) {
+  const { data: s, indices: a } = t, i = e.typedBuffer, n = e.typedBufferStride, o = a.length;
+  r *= n;
+  for (let c = 0; c < o; ++c) {
+    const d = 2 * a[c];
+    i[r] = s[d], i[r + 1] = s[d + 1], r += n;
+  }
+}
+function Qr(t, e, r, s) {
+  const { data: a, indices: i } = t, n = e.typedBuffer, o = e.typedBufferStride, c = i.length;
+  if (r *= o, s == null || s === 1)
+    for (let d = 0; d < c; ++d) {
+      const u = 3 * i[d];
+      n[r] = a[u], n[r + 1] = a[u + 1], n[r + 2] = a[u + 2], r += o;
+    }
+  else
+    for (let d = 0; d < c; ++d) {
+      const u = 3 * i[d];
+      for (let h = 0; h < s; ++h)
+        n[r] = a[u], n[r + 1] = a[u + 1], n[r + 2] = a[u + 2], r += o;
+    }
+}
+function Zr(t, e, r, s = 1) {
+  const { data: a, indices: i } = t, n = e.typedBuffer, o = e.typedBufferStride, c = i.length;
+  if (r *= o, s === 1)
+    for (let d = 0; d < c; ++d) {
+      const u = 4 * i[d];
+      n[r] = a[u], n[r + 1] = a[u + 1], n[r + 2] = a[u + 2], n[r + 3] = a[u + 3], r += o;
+    }
+  else
+    for (let d = 0; d < c; ++d) {
+      const u = 4 * i[d];
+      for (let h = 0; h < s; ++h)
+        n[r] = a[u], n[r + 1] = a[u + 1], n[r + 2] = a[u + 2], n[r + 3] = a[u + 3], r += o;
+    }
+}
+function Ic(t, e, r) {
+  const s = t.typedBuffer, a = t.typedBufferStride;
+  e *= a;
+  for (let i = 0; i < r; ++i)
+    s[e] = 0, s[e + 1] = 0, s[e + 2] = 0, s[e + 3] = 0, e += a;
+}
+function Vi(t, e, r, s, a = 1) {
+  if (!e)
+    return void Qr(t, r, s, a);
+  const { data: i, indices: n } = t, o = r.typedBuffer, c = r.typedBufferStride, d = n.length, u = e[0], h = e[1], v = e[2], O = e[4], S = e[5], V = e[6], G = e[8], F = e[9], k = e[10], y = e[12], I = e[13], C = e[14];
+  s *= c;
+  let w = 0, T = 0, E = 0;
+  const A = ur(e) ? (g) => {
+    w = i[g] + y, T = i[g + 1] + I, E = i[g + 2] + C;
+  } : (g) => {
+    const f = i[g], p = i[g + 1], _ = i[g + 2];
+    w = u * f + O * p + G * _ + y, T = h * f + S * p + F * _ + I, E = v * f + V * p + k * _ + C;
+  };
+  if (a === 1)
+    for (let g = 0; g < d; ++g)
+      A(3 * n[g]), o[s] = w, o[s + 1] = T, o[s + 2] = E, s += c;
+  else
+    for (let g = 0; g < d; ++g) {
+      A(3 * n[g]);
+      for (let f = 0; f < a; ++f)
+        o[s] = w, o[s + 1] = T, o[s + 2] = E, s += c;
+    }
+}
+function zi(t, e, r, s, a = 1) {
+  if (!e)
+    return void Qr(t, r, s, a);
+  const { data: i, indices: n } = t, o = e, c = r.typedBuffer, d = r.typedBufferStride, u = n.length, h = o[0], v = o[1], O = o[2], S = o[4], V = o[5], G = o[6], F = o[8], k = o[9], y = o[10], I = !dr(o), C = 1e-6, w = 1 - C;
+  s *= d;
+  let T = 0, E = 0, A = 0;
+  const g = ur(o) ? (f) => {
+    T = i[f], E = i[f + 1], A = i[f + 2];
+  } : (f) => {
+    const p = i[f], _ = i[f + 1], $ = i[f + 2];
+    T = h * p + S * _ + F * $, E = v * p + V * _ + k * $, A = O * p + G * _ + y * $;
+  };
+  if (a === 1)
+    if (I)
+      for (let f = 0; f < u; ++f) {
+        g(3 * n[f]);
+        const p = T * T + E * E + A * A;
+        if (p < w && p > C) {
+          const _ = 1 / Math.sqrt(p);
+          c[s] = T * _, c[s + 1] = E * _, c[s + 2] = A * _;
+        } else
+          c[s] = T, c[s + 1] = E, c[s + 2] = A;
+        s += d;
+      }
+    else
+      for (let f = 0; f < u; ++f)
+        g(3 * n[f]), c[s] = T, c[s + 1] = E, c[s + 2] = A, s += d;
+  else
+    for (let f = 0; f < u; ++f) {
+      if (g(3 * n[f]), I) {
+        const p = T * T + E * E + A * A;
+        if (p < w && p > C) {
+          const _ = 1 / Math.sqrt(p);
+          T *= _, E *= _, A *= _;
+        }
+      }
+      for (let p = 0; p < a; ++p)
+        c[s] = T, c[s + 1] = E, c[s + 2] = A, s += d;
+    }
+}
+function Gi(t, e, r, s, a = 1) {
+  if (!e)
+    return void Zr(t, r, s, a);
+  const { data: i, indices: n } = t, o = e, c = r.typedBuffer, d = r.typedBufferStride, u = n.length, h = o[0], v = o[1], O = o[2], S = o[4], V = o[5], G = o[6], F = o[8], k = o[9], y = o[10], I = !dr(o), C = 1e-6, w = 1 - C;
+  if (s *= d, a === 1)
+    for (let T = 0; T < u; ++T) {
+      const E = 4 * n[T], A = i[E], g = i[E + 1], f = i[E + 2], p = i[E + 3];
+      let _ = h * A + S * g + F * f, $ = v * A + V * g + k * f, N = O * A + G * g + y * f;
+      if (I) {
+        const P = _ * _ + $ * $ + N * N;
+        if (P < w && P > C) {
+          const W = 1 / Math.sqrt(P);
+          _ *= W, $ *= W, N *= W;
+        }
+      }
+      c[s] = _, c[s + 1] = $, c[s + 2] = N, c[s + 3] = p, s += d;
+    }
+  else
+    for (let T = 0; T < u; ++T) {
+      const E = 4 * n[T], A = i[E], g = i[E + 1], f = i[E + 2], p = i[E + 3];
+      let _ = h * A + S * g + F * f, $ = v * A + V * g + k * f, N = O * A + G * g + y * f;
+      if (I) {
+        const P = _ * _ + $ * $ + N * N;
+        if (P < w && P > C) {
+          const W = 1 / Math.sqrt(P);
+          _ *= W, $ *= W, N *= W;
+        }
+      }
+      for (let P = 0; P < a; ++P)
+        c[s] = _, c[s + 1] = $, c[s + 2] = N, c[s + 3] = p, s += d;
+    }
+}
+function Wi(t, e, r, s, a = 1) {
+  const { data: i, indices: n } = t, o = r.typedBuffer, c = r.typedBufferStride, d = n.length;
+  if (s *= c, e !== i.length || e !== 4)
+    if (a !== 1)
+      if (e !== 4)
+        for (let u = 0; u < d; ++u) {
+          const h = 3 * n[u];
+          for (let v = 0; v < a; ++v)
+            o[s] = i[h], o[s + 1] = i[h + 1], o[s + 2] = i[h + 2], o[s + 3] = 255, s += c;
+        }
+      else
+        for (let u = 0; u < d; ++u) {
+          const h = 4 * n[u];
+          for (let v = 0; v < a; ++v)
+            o[s] = i[h], o[s + 1] = i[h + 1], o[s + 2] = i[h + 2], o[s + 3] = i[h + 3], s += c;
+        }
+    else {
+      if (e === 4) {
+        for (let u = 0; u < d; ++u) {
+          const h = 4 * n[u];
+          o[s] = i[h], o[s + 1] = i[h + 1], o[s + 2] = i[h + 2], o[s + 3] = i[h + 3], s += c;
+        }
+        return;
+      }
+      for (let u = 0; u < d; ++u) {
+        const h = 3 * n[u];
+        o[s] = i[h], o[s + 1] = i[h + 1], o[s + 2] = i[h + 2], o[s + 3] = 255, s += c;
+      }
+    }
+  else {
+    o[s] = i[0], o[s + 1] = i[1], o[s + 2] = i[2], o[s + 3] = i[3];
+    const u = new Uint32Array(r.typedBuffer.buffer, r.start), h = c / 4, v = u[s /= 4];
+    s += h;
+    const O = d * a;
+    for (let S = 1; S < O; ++S)
+      u[s] = v, s += h;
+  }
+}
+function ki(t, e, r) {
+  const { data: s, indices: a } = t, i = e.typedBuffer, n = e.typedBufferStride, o = a.length, c = s[0];
+  r *= n;
+  for (let d = 0; d < o; ++d)
+    i[r] = c, r += n;
+}
+function ji(t, e, r, s, a = 1) {
+  const i = e.typedBuffer, n = e.typedBufferStride;
+  if (s *= n, a === 1)
+    for (let o = 0; o < r; ++o)
+      i[s] = t[0], i[s + 1] = t[1], i[s + 2] = t[2], i[s + 3] = t[3], s += n;
+  else
+    for (let o = 0; o < r; ++o)
+      for (let c = 0; c < a; ++c)
+        i[s] = t[0], i[s + 1] = t[1], i[s + 2] = t[2], i[s + 3] = t[3], s += n;
+}
+function qi(t, e, r, s, a, i) {
+  var n;
+  for (const o of e.fields.keys()) {
+    const c = t.attributes.get(o), d = c == null ? void 0 : c.indices;
+    if (c && d)
+      Xi(o, c, r, s, a, i);
+    else if (o === m.OBJECTANDLAYERIDCOLOR && t.objectAndLayerIdColor != null) {
+      const u = (n = t.attributes.get(m.POSITION)) == null ? void 0 : n.indices;
+      if (u) {
+        const h = u.length, v = a.getField(o, fr);
+        ji(t.objectAndLayerIdColor, v, h, i);
+      }
+    }
+  }
+}
+function Xi(t, e, r, s, a, i) {
+  switch (t) {
+    case m.POSITION: {
+      U(e.size === 3);
+      const n = a.getField(t, Vt);
+      U(!!n, `No buffer view for ${t}`), n && Vi(e, r, n, i);
+      break;
+    }
+    case m.NORMAL: {
+      U(e.size === 3);
+      const n = a.getField(t, Vt);
+      U(!!n, `No buffer view for ${t}`), n && zi(e, s, n, i);
+      break;
+    }
+    case m.NORMALCOMPRESSED: {
+      U(e.size === 2);
+      const n = a.getField(t, Ws);
+      U(!!n, `No buffer view for ${t}`), n && ar(e, n, i);
+      break;
+    }
+    case m.UV0: {
+      U(e.size === 2);
+      const n = a.getField(t, Gs);
+      U(!!n, `No buffer view for ${t}`), n && ar(e, n, i);
+      break;
+    }
+    case m.COLOR:
+    case m.SYMBOLCOLOR: {
+      const n = a.getField(t, fr);
+      U(!!n, `No buffer view for ${t}`), U(e.size === 3 || e.size === 4), !n || e.size !== 3 && e.size !== 4 || Wi(e, e.size, n, i);
+      break;
+    }
+    case m.COLORFEATUREATTRIBUTE: {
+      const n = a.getField(t, zs);
+      U(!!n, `No buffer view for ${t}`), U(e.size === 1), n && e.size === 1 && ki(e, n, i);
+      break;
+    }
+    case m.TANGENT: {
+      U(e.size === 4);
+      const n = a.getField(t, Ut);
+      U(!!n, `No buffer view for ${t}`), n && Gi(e, s, n, i);
+      break;
+    }
+    case m.PROFILERIGHT:
+    case m.PROFILEUP:
+    case m.PROFILEVERTEXANDNORMAL:
+    case m.FEATUREVALUE: {
+      U(e.size === 4);
+      const n = a.getField(t, Ut);
+      U(!!n, `No buffer view for ${t}`), n && Zr(e, n, i);
+    }
+  }
+}
+const Yi = hr(1, 1, 0, 1), Ki = hr(1, 0, 1, 1);
+function $c(t) {
+  t.fragment.uniforms.add(new We("depthTexture", (e, r) => r.mainDepth)), t.fragment.constants.add("occludedHighlightFlag", "vec4", Yi).add("unoccludedHighlightFlag", "vec4", Ki), t.fragment.code.add(l`void outputHighlight() {
+float sceneDepth = float(texelFetch(depthTexture, ivec2(gl_FragCoord.xy), 0).x);
+if (gl_FragCoord.z > sceneDepth + 5e-7) {
+fragColor = occludedHighlightFlag;
+} else {
+fragColor = unoccludedHighlightFlag;
+}
+}`);
+}
+class Lc {
+  constructor(e) {
+    this.vertexBufferLayout = e;
+  }
+  elementCount(e) {
+    return e.attributes.get(m.POSITION).indices.length;
+  }
+  write(e, r, s, a, i) {
+    qi(s, this.vertexBufferLayout, e, r, a, i);
+  }
+}
+function yc(t) {
+  Pr(t), t.vertex.code.add(l`vec4 transformPositionWithDepth(mat4 proj, mat4 view, vec3 pos, vec2 nearFar, out float depth) {
+vec4 eye = view * vec4(pos, 1.0);
+depth = calculateLinearDepth(nearFar,eye.z);
+return proj * eye;
+}`), t.vertex.code.add(l`vec4 transformPosition(mat4 proj, mat4 view, vec3 pos) {
+return proj * (view * vec4(pos, 1.0));
+}`);
+}
+function Cc(t, e) {
+  e.hasVertexColors ? (t.attributes.add(m.COLOR, "vec4"), t.varyings.add("vColor", "vec4"), t.vertex.code.add(l`void forwardVertexColor() { vColor = color; }`), t.vertex.code.add(l`void forwardNormalizedVertexColor() { vColor = color * 0.003921568627451; }`)) : t.vertex.code.add(l`void forwardVertexColor() {}
+void forwardNormalizedVertexColor() {}`);
+}
+export {
+  cc as $,
+  oo as A,
+  In as B,
+  Sn as C,
+  xn as D,
+  io as E,
+  Rn as F,
+  Cn as G,
+  Qn as H,
+  kt as I,
+  Yn as J,
+  oa as K,
+  vr as L,
+  wi as M,
+  Io as N,
+  Ea as O,
+  Wo as P,
+  ja as Q,
+  Xt as R,
+  ic as S,
+  Aa as T,
+  Vo as U,
+  bc as V,
+  Da as W,
+  Go as X,
+  Cc as Y,
+  ec as Z,
+  Ro as _,
+  xc as a,
+  No as a$,
+  dc as a0,
+  uc as a1,
+  vo as a2,
+  sc as a3,
+  st as a4,
+  ke as a5,
+  dt as a6,
+  yo as a7,
+  kn as a8,
+  aa as a9,
+  lc as aA,
+  hc as aB,
+  nc as aC,
+  na as aD,
+  jn as aE,
+  $a as aF,
+  Po as aG,
+  _c as aH,
+  tc as aI,
+  Ko as aJ,
+  Qo as aK,
+  Yt as aL,
+  gc as aM,
+  go as aN,
+  Ei as aO,
+  lo as aP,
+  Fi as aQ,
+  Ui as aR,
+  Ba as aS,
+  Di as aT,
+  Rc as aU,
+  Yi as aV,
+  Ki as aW,
+  ia as aX,
+  Or as aY,
+  ro as aZ,
+  to as a_,
+  ao as aa,
+  so as ab,
+  Sc as ac,
+  Lc as ad,
+  Ao as ae,
+  Zo as af,
+  Lo as ag,
+  gn as ah,
+  yt as ai,
+  ks as aj,
+  js as ak,
+  qs as al,
+  Xs as am,
+  $e as an,
+  Ta as ao,
+  Jn as ap,
+  Xn as aq,
+  va as ar,
+  ka as as,
+  pr as at,
+  Ho as au,
+  er as av,
+  Pr as aw,
+  Wn as ax,
+  oc as ay,
+  mc as az,
+  ac as b,
+  La as b0,
+  Vi as b1,
+  zi as b2,
+  Wi as b3,
+  Zr as b4,
+  Ic as b5,
+  ji as b6,
+  qn as b7,
+  Ac as b8,
+  wo as b9,
+  qi as ba,
+  Ie as c,
+  x as d,
+  q as e,
+  Bo as f,
+  yc as g,
+  Ra as h,
+  $c as i,
+  Sa as j,
+  K as k,
+  Xo as l,
+  Yo as m,
+  po as n,
+  Qs as o,
+  ko as p,
+  Ha as q,
+  Q as r,
+  We as s,
+  bo as t,
+  Ia as u,
+  lt as v,
+  Ct as w,
+  ot as x,
+  j as y,
+  Dn as z
+};